cukedep 0.0.8 → 0.1.03

data/spec/cukedep/gherkin-facade_spec.rb

@@ -0,0 +1,54 @@
+# File: file-actions_spec.rb
+
+require_relative '../spec_helper'
+
+# Load the class under testing
+require_relative '../../lib/cukedep/gherkin-facade'
+require_relative '../../lib/cukedep/gherkin-listener'
+
+module Cukedep # Open module to get rid of long qualified names
+
+describe GherkinFacade do
+  subject { GherkinFacade.new(false, 'UTF-8') }
+
+  context 'Creation & initialization:' do
+    it 'should be created with two arguments' do
+      expect { GherkinFacade.new(true, 'UTF-8') }.not_to raise_error
+    end
+    
+    it 'should whether it is verbose or not' do
+      # Case 1: instance is verbose
+      expect(subject.verbose).to be_false
+      
+      # Case 2: instance is silent
+      instance =  GherkinFacade.new(true, 'UTF-8')
+      expect(instance.verbose).to be_true 
+    end
+    
+    it 'should know the feature file external encoding' do
+      expect(subject.external_encoding).to eq('UTF-8')
+    end
+  
+  end # context
+
+
+  
+  context 'Provided services:' do
+    let(:listener) { GherkinListener.new }
+    it 'should parse ASCII feature files' do
+      instance = GherkinFacade.new(false, 'US-ASCII')
+      patterns = [ 'sample_features/a_few_tests.feature' ]
+      expect {instance.parse_features(listener, patterns)}.not_to raise_error
+    end
+    
+    it 'should parse feature files with other external encoding' do
+      patterns = [ 'sample_features/standalone.feature' ]
+      expect {subject.parse_features(listener, patterns)}.not_to raise_error
+    end
+  end # context
+
+end # describe
+
+end # module
+
+# End of file

data/spec/cukedep/hook-dsl_spec.rb

@@ -0,0 +1,185 @@
+# File: file-action_spec.rb
+
+require 'stringio'
+require_relative '../spec_helper'
+
+# Load the class under testing
+require_relative '../../lib/cukedep/hook-dsl'
+
+module Cukedep # Open module to get rid of long qualified names
+
+# Let's specify the behaviour of the mix-in module
+describe HookDSL do
+
+  subject do
+    obj = Object.new
+    obj.extend(HookDSL)
+    obj
+  end
+
+  context 'Hook definitions:' do
+    let(:code_block) do
+      -> { ; }
+    end
+
+    it 'should accept the before all hook' do
+      # Case 1: before all with block code
+      expect { subject.before_cuke(:all, &code_block) }.not_to raise_error
+
+      # Case 2: before all without block code
+      expect { subject.before_cuke(:all) }.not_to raise_error
+    end
+
+    it 'should accept the before each hook' do
+      # Case 1: before each with block code
+      expect { subject.before_cuke(:each, &code_block) }.not_to raise_error
+
+      # Case 2: before each without block code
+      expect { subject.before_cuke(:each) }.not_to raise_error
+    end
+
+
+    it 'should accept the after all hook' do
+      # Case 1: after all with block code
+      expect { subject.after_cuke(:all, &code_block) }.not_to raise_error
+
+      # Case 2: before all without block code
+      expect { subject.after_cuke(:all) }.not_to raise_error
+    end
+
+    it 'should accept the after each hook' do
+      # Case 1: after each with block code
+      expect { subject.after_cuke(:each, &code_block) }.not_to raise_error
+
+      # Case 2: after each without block code
+      expect { subject.after_cuke(:each) }.not_to raise_error
+    end
+
+    it 'should reject invalid scope argument' do
+      # Case 1: before invalid with block code
+      msg = "Unknown scope 'invalid' for before_cuke hook."
+      error = StandardError
+      expect { subject.before_cuke(:invalid, &code_block) }.to raise_error(error, msg)
+
+      # Case 2: after invalid with block code
+      msg = "Unknown scope 'invalid' for after_cuke hook."
+      expect { subject.after_cuke(:invalid, &code_block) }.to raise_error(error, msg)
+    end
+
+
+    it 'should register the block code with the event' do
+      # No block code registered yet.
+      expect(subject.instance_variables).not_to include(:@before_hooks)
+
+      # Case 1: No before all handler provided
+      subject.before_cuke(:all)
+      expect(subject.instance_variables).not_to include(:@before_hooks)
+
+      # Case 1: Add before all handler
+      subject.before_cuke(:all, &code_block)
+
+      # Check that handler code is stored in instance variable
+      expect(subject.instance_variables).to include(:@before_hooks)
+      expect(subject.before_hooks.keys).to eq([:all])
+      expect(subject.before_hooks[:all]).to eq(code_block)
+
+      # Case 2: No before each handler provided
+      subject.before_cuke(:each)
+      expect(subject.before_hooks.keys).to eq([:all])
+
+      # Case 3: Add before each handler
+      subject.before_cuke(:each, &code_block)
+
+      # Check that handler code is stored in instance variable
+      expect(subject.before_hooks.keys).to eq([:all, :each])
+      expect(subject.before_hooks[:each]).to eq(code_block)
+
+
+      # Case 4: No after all handler provided
+      subject.after_cuke(:all)
+      expect(subject.instance_variables).not_to include(:@after_hooks)
+
+      # Case 5: Add after all handler
+      subject.after_cuke(:all, &code_block)
+
+      # Check that handler code is stored in instance variable
+      expect(subject.instance_variables).to include(:@after_hooks)
+      expect(subject.after_hooks.keys).to eq([:all])
+      expect(subject.after_hooks[:all]).to eq(code_block)
+
+      # Case 6: No after each handler provided
+      subject.after_cuke(:each)
+      expect(subject.after_hooks.keys).to eq([:all])
+
+      # Case 7: Add after each handler
+      subject.after_cuke(:each, &code_block)
+
+      # Check that handler code is stored in instance variable
+      expect(subject.after_hooks.keys).to eq([:all, :each])
+      expect(subject.after_hooks[:each]).to eq(code_block)
+    end
+
+  end # context
+=begin
+  context 'Executing handler code:' do
+    let(:ostream) { StringIO.new('', 'w') }
+    
+    it 'should ignore missing handler' do
+      expect { subject.execute_hook(:before, :all) }.not_to raise_error
+    end
+
+    it 'should execute the before all handler' do
+      text = 'before all'
+      # Let's create the hook
+      subject.before_cuke(:all) { ostream.print text }
+
+      # Let's execute it...
+      subject.execute_hook(:before, :all)
+
+      expect(ostream.string).to eq(text)
+    end
+
+
+    it 'should execute the before all handler' do
+      text = 'before each'
+      # Let's create the hook
+      subject.before_cuke(:each) { ostream.print text }
+
+      # Let's execute it...
+      subject.execute_hook(:before, :each)
+
+      expect(ostream.string).to eq(text)
+    end
+
+
+    it 'should execute the after all handler' do
+      text = 'after all'
+      # Let's create the hook
+      subject.after_cuke(:all) { ostream.print text }
+
+      # Let's execute it...
+      subject.execute_hook(:after, :all)
+
+      expect(ostream.string).to eq(text)
+    end
+
+
+    it 'should execute the after each handler' do
+      text = 'after each'
+      # Let's create the hook
+      subject.after_cuke(:each) { ostream.print text }
+
+      # Let's execute it...
+      subject.execute_hook(:after, :each)
+
+      expect(ostream.string).to eq(text)
+    end
+
+  end # context
+=end
+
+end # describe
+
+end # module
+
+# End of file

data/spec/cukedep/sample_features/cukedep.rake

@@ -0,0 +1,204 @@
+# File: cukedep.rake
+# Generated by Cukedep 0.1.01 on 27/11/2013 23:12:50
+
+require 'rake'
+require 'cukedep/file-action'
+
+# Run Cucumber via specialized Rake task
+require 'cucumber/rake/task'
+# UGLY workaround for bug in Cucumber's rake task
+if Gem::VERSION[0].to_i >= 2 && Cucumber::VERSION <= '1.3.2'
+  # Monkey-patch a buggy method
+  class Cucumber::Rake::Task::ForkedCucumberRunner
+    def gem_available?(gemname)
+      if Gem::VERSION[0].to_i >= 2 
+        gem_available_new_rubygems?(gemname)
+      else
+        gem_available_old_rubygems?(gemname)
+      end
+    end  
+  end # class
+end
+
+# Create a task called cucumber
+Cucumber::Rake::Task.new do |t|
+end
+
+#######################################
+# Retrieving state at end of Cukedep::Application#run! method
+#######################################
+
+# Constant holding the location of the original feature files
+SOURCE_DIR = 'C:/Ruby193/lib/ruby/site_ruby/Cukedep/spec/cukedep/sample_features'
+
+# Constant holding the location of the Cucumber project
+CUKE_PROJECT = 'C:/Ruby193/lib/ruby/site_ruby/Cukedep/sample'
+
+# The list of all "legacy" feature file (feature files without the @feature: tag)
+AllUnidentifiedFeatures = [
+  'standalone.feature'
+]
+  
+# The list of all encountered feature ids
+AllFeatureIdentifiers = [ 
+  :qux,
+  :quux,
+  :corge,
+  :foo,
+  :baz,
+  :bar
+]
+
+
+def run_builtin_actions(anEvent)
+  actions = Cukedep::ActionTriplet.builtin(anEvent)
+  actions.run!(SOURCE_DIR, CUKE_PROJECT) unless actions.nil?
+end
+
+# Helper method. Calculate the filepath of a file with given name
+# if it is located in the source dir.
+def source_path_of(aFilename)
+  SOURCE_DIR + '/' + aFilename
+end
+
+# Helper method. Calculate the filepath of a file with given name
+# if it is located in the project features dir.
+def project_path_of(aFilename)
+  CUKE_PROJECT + '/features/' + aFilename
+end
+
+# Helper method. Given the name of files in the source dir, copy them 
+# into the project dir.
+def copy_to_project(filenames)
+  filenames.each do |fname|
+    source_path = source_path_of(fname)
+    dest_path = project_path_of(fname)
+    FileUtils.copy_file(source_path, dest_path)
+  end
+end
+
+
+# Helper method. Given the name of files in the features dir of the project, 
+# copy them into the source dir.
+def copy_from_project(*filenames)
+  filenames.each do |fname|
+    source_path =  project_path_of(fname)
+    dest_path = source_path_of(fname)
+    FileUtils.copy_file(source_path, dest_path)
+  end
+end
+
+# Helper method. Delete all the files in the 
+# the project's features dir that match one of 
+# the file name pattern
+def clean_project_dir(fname_patterns)
+  curr_dir = Dir.getwd()
+  begin
+    Dir.chdir(CUKE_PROJECT + '/features')
+    fname_patterns.each do |patt|
+      filenames = Dir.glob(patt)
+      filenames.each { |fn| FileUtils.remove_file(fn) }
+    end
+  ensure  #Always restore previous working dir.
+    Dir.chdir(curr_dir)
+  end
+end
+
+
+# Helper method. Invoke Cucumber with the given project root dir.
+# Assumption: all features files to execute are placed 
+# in the appropriate folder.
+def invoke_cuke(projectDir)
+  curr_dir = Dir.getwd()
+  Dir.chdir(projectDir)
+  begin
+    do_cuke = Rake::Task[:cucumber]
+    do_cuke.reenable
+    do_cuke.invoke
+  ensure
+    Dir.chdir(curr_dir)
+  end
+end
+
+
+def process_files(filenames)
+  run_builtin_actions(:before_each)
+  copy_to_project(filenames)
+  invoke_cuke(CUKE_PROJECT)
+  run_builtin_actions(:after_each)
+  #del_from_project(filenames)
+end
+
+def process_a_feature(filename)
+  process_files([filename])
+end
+
+
+# Default rake task is also top-level task
+task :default => :run_all_features
+
+
+desc 'Run all features'
+task :run_all_features => [:before_all, :all_features, :after_all] do
+  ; # Do nothing
+end
+
+
+desc 'Before all' 
+task :before_all do
+  run_builtin_actions(:before_all)
+end
+
+desc 'After_all'
+task :after_all do
+  run_builtin_actions(:after_all)
+end
+
+
+task :unidentified do
+  process_files(AllUnidentifiedFeatures)
+end
+
+# Tasks for feature files involved in dependencies
+
+
+desc "qux: run a_few_tests.feature"
+task :qux  do
+  process_a_feature('a_few_tests.feature')
+end
+
+
+desc "quux: run more_tests.feature"
+task :quux  do
+  process_a_feature('more_tests.feature')
+end
+
+
+desc "corge: run other_tests.feature"
+task :corge => [:foo] do
+  process_a_feature('other_tests.feature')
+end
+
+
+desc "foo: run some_tests.feature"
+task :foo => [:bar, :qux] do
+  process_a_feature('some_tests.feature')
+end
+
+
+desc "baz: run still_other_tests.feature"
+task :baz  do
+  process_a_feature('still_other_tests.feature')
+end
+
+
+desc "bar: run yet_other_tests.feature"
+task :bar => [:baz, :qux, :quux] do
+  process_a_feature('yet_other_tests.feature')
+end
+
+
+task :all_features => ([:unidentified] + AllFeatureIdentifiers) do
+end
+
+# End of file

data/spec/cukedep/sample_features/cukedep_hooks.rb

@@ -0,0 +1,30 @@
+# File: cukedep_hooks.rb
+# This Ruby file specifies the custom code
+# associated with Cukedep hooks.
+
+# The code block will be executed before
+# the very first Cucumber invocation.
+before_cuke(:all) do
+  puts 'before all'
+end
+
+# The code block will be executed just before
+# a Cucumber invocation.
+# The argument is a frozen Array of feature file names
+before_cuke(:each) do |filenames|
+  puts 'before each'
+end
+
+# The code block will be executed just after
+# a Cucumber invocation.
+after_cuke(:each) do
+  puts 'after each'
+end
+
+# The code block will be executed just after
+# the last Cucumber invocation.
+after_cuke(:all) do
+  puts 'after all'  
+end
+
+# End of file