cucumber 2.0.0.beta.5 → 2.0.0.rc.1

data/spec/cucumber/cli/configuration_spec.rb

@@ -398,7 +398,22 @@ END_OF_MESSAGE
       expect(config.feature_files).to eq ["cucumber.feature"]
     end
 
-    it "allows specifying environment variables on the command line" do
+    it "gets the feature files from the rerun file" do
+      allow(File).to receive(:directory?).and_return(false)
+      allow(File).to receive(:file?).and_return(true)
+      allow(IO).to receive(:read).and_return(
+        "cucumber.feature:1:3 cucumber space.feature:134 domain folder/cuke.feature:1 domain folder/different cuke:4:5" )
+
+      config.parse!(%w{@rerun.txt})
+
+      expect(config.feature_files).to eq [
+        "cucumber.feature:1:3",
+        "cucumber space.feature:134",
+        "domain folder/cuke.feature:1",
+        "domain folder/different cuke:4:5"]
+    end
+
+    it "should allow specifying environment variables on the command line" do
       config.parse!(["foo=bar"])
 
       expect(ENV["foo"]).to eq "bar"

data/spec/cucumber/cli/profile_loader_spec.rb

@@ -31,6 +31,16 @@ module Cucumber
 
         expect(loader.args_from('default')).to eq ['--format','ugly','features/sync_imap_mailbox.feature:16:22']
       end
+
+      it "treats percent sign as ERB code block after YAML directive" do
+        yml = <<-HERE
+---
+% x = '--format "pretty" features/sync_imap_mailbox.feature:16:22'
+default: <%= x %>
+        HERE
+        given_cucumber_yml_defined_as yml
+        expect(loader.args_from('default')).to eq ['--format','pretty','features/sync_imap_mailbox.feature:16:22']
+      end
     end
   end
 end

data/spec/cucumber/file_specs_spec.rb

@@ -4,6 +4,7 @@ module Cucumber
   describe FileSpecs do
     let(:file_specs) { FileSpecs.new(["features/foo.feature:1:2:3", "features/bar.feature:4:5:6"]) }
     let(:locations) { file_specs.locations }
+    let(:files) { file_specs.files }
 
     it "parses locations from multiple files" do
       expect(locations.length).to eq 6
@@ -18,8 +19,6 @@ module Cucumber
     end
 
     it "parses file names from multiple file specs" do
-      files = file_specs.files
-
       expect(files.length).to eq 2
       expect(files).to eq [
         "features/foo.feature",
@@ -27,6 +26,15 @@ module Cucumber
       ]
     end
 
+    context "when files are not unique" do
+      let(:file_specs) { FileSpecs.new(["features/foo.feature:4", "features/foo.feature:34"]) }
+
+      it "parses unique file names" do
+        expect(files.length).to eq 1
+        expect(files).to eq ["features/foo.feature"]
+      end
+    end
+
     context "when no line number is specified" do
       let(:file_specs) { FileSpecs.new(["features/foo.feature", "features/bar.feature:34"]) }
 

data/spec/cucumber/filters/activate_steps_spec.rb

@@ -0,0 +1,57 @@
+require 'cucumber/filters/activate_steps'
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/core'
+
+describe Cucumber::Filters::ActivateSteps do
+  include Cucumber::Core::Gherkin::Writer
+  include Cucumber::Core
+
+  let(:step_definitions) { double(find_match: step_match) }
+  let(:step_match) { double(activate: activated_test_step) }
+  let(:activated_test_step) { double }
+  let(:receiver) { double.as_null_object }
+
+  context "a scenario with a single step" do
+    let(:doc) do
+      gherkin do
+        feature do
+          scenario do
+            step 'a passing step'
+          end
+        end
+      end
+    end
+
+    it "activates each step" do
+      expect(step_match).to receive(:activate) do |test_step|
+        expect(test_step.name).to eq 'a passing step'
+      end
+      compile [doc], receiver, [Cucumber::Filters::ActivateSteps.new(step_definitions)]
+    end
+  end
+
+  context "a scenario outline" do
+    let(:doc) do
+      gherkin do
+        feature do
+          scenario_outline do
+            step 'a <status> step'
+
+            examples do
+              row 'status'
+              row 'passing'
+            end
+          end
+        end
+      end
+    end
+
+    it "activates each step" do
+      expect(step_match).to receive(:activate) do |test_step|
+        expect(test_step.name).to eq 'a passing step'
+      end
+      compile [doc], receiver, [Cucumber::Filters::ActivateSteps.new(step_definitions)]
+    end
+  end
+
+end

data/spec/cucumber/formatter/debug_spec.rb

@@ -37,14 +37,6 @@ feature_name
 before_test_step
 after_test_step
 before_test_step
-after_test_step
-before_test_step
-after_test_step
-before_test_step
-after_test_step
-before_test_step
-after_test_step
-before_test_step
 before_feature_element
 before_tags
 after_tags
@@ -56,12 +48,6 @@ step_name
 after_step_result
 after_step
 after_test_step
-before_test_step
-after_test_step
-before_test_step
-after_test_step
-before_test_step
-after_test_step
 after_steps
 after_feature_element
 after_test_case

data/spec/cucumber/formatter/html_spec.rb

@@ -29,6 +29,35 @@ module Cucumber
         }).not_to raise_error
       end
 
+      describe "when writing the report to a file" do
+        before(:each) do
+          allow(@out).to receive(:respond_to?).with(:path, false).and_return(true)
+          expect(@out).to receive(:respond_to?).with(:path).and_return(true)
+          expect(@out).to receive(:path).and_return('out/file.html')
+          run_defined_feature
+          @doc = Nokogiri.HTML(@out.string)
+        end
+
+        describe "with a step that embeds a snapshot" do
+          define_steps do
+            Given(/snap/) { 
+              RSpec::Mocks.allow_message(File, :file?) { true }
+              embed('out/snapshot.jpeg', 'image/jpeg')
+            }
+          end
+
+          define_feature(<<-FEATURE)
+          Feature:
+            Scenario:
+              Given snap
+            FEATURE
+
+          it "converts the snapshot path to a relative path" do
+            expect(@doc.css('.embed img').first.attributes['src'].to_s).to eq "snapshot.jpeg"
+          end
+        end
+      end
+
       describe "given a single feature" do
         before(:each) do
           run_defined_feature

data/spec/cucumber/formatter/legacy_api/adapter_spec.rb

@@ -1,7 +1,10 @@
 require 'cucumber/formatter/legacy_api/adapter'
 require 'cucumber/core'
 require 'cucumber/core/gherkin/writer'
-require 'cucumber/mappings'
+require 'cucumber/runtime/step_hooks'
+require 'cucumber/runtime/before_hooks'
+require 'cucumber/runtime/after_hooks'
+require 'cucumber/filters'
 
 module Cucumber
   module Formatter::LegacyApi
@@ -12,25 +15,52 @@ module Cucumber
       let(:report)    { Adapter.new(formatter, runtime.results, runtime.support_code, runtime.configuration) }
       let(:formatter) { double('formatter').as_null_object }
       let(:runtime)   { Runtime.new }
-      let(:mappings)  { mappings = CustomMappings.new }
 
       Failure = Class.new(StandardError)
 
-      class CustomMappings
-        def test_case(test_case, mapper)
-          # The adapter is built on the assumption that each test case will have at least one step. This is annoying
-          # for tests, but a safe assumption for production use as we always add one hook to initialize the world.
-          mapper.before {}
+      class SimpleStepMatch
+        def initialize(&block)
+          @block = block
+        end
+
+        def activate(test_step)
+          test_step.with_action &@block
         end
+      end
 
-        def test_step(test_step, mapper)
+      class SimpleStepDefinitions
+        def find_match(test_step)
           if test_step.name =~ /pass/
-            mapper.map {}
+            return SimpleStepMatch.new {}
           end
 
           if test_step.name =~ /fail/
-            mapper.map { raise Failure }
+            return SimpleStepMatch.new { raise Failure }
           end
+
+          NoStepMatch.new test_step.source.last, test_step.name
+        end
+      end
+
+      class AddBeforeAndAfterHooks < Core::Filter.new
+        def test_case(test_case)
+          steps = before_hooks(test_case.source) + 
+            test_case.test_steps +
+            after_hooks(test_case.source)
+          test_case.with_steps(steps).describe_to receiver
+        end
+
+        private
+
+        def before_hooks(source)
+          # The adapter is built on the assumption that each test case will have at least one step. This is annoying
+          # for tests, but a safe assumption for production use as we always add one hook to initialize the world.
+          [ Hooks.before_hook(source) {} ]
+        end
+
+        def after_hooks(source)
+          # We add an after hook to make sure the adapter can cope with it
+          [ Hooks.after_hook(source) {} ]
         end
       end
 
@@ -54,44 +84,45 @@ module Cucumber
               end
             end,
           ]
-          execute gherkin_docs, mappings, report
+          runner = Core::Test::Runner.new(report)
+          compile gherkin_docs, runner, default_filters
           expect( formatter.legacy_messages ).to eq [
-              :before_features,
-                :before_feature,
+            :before_features,
+              :before_feature,
+                :before_tags,
+                :after_tags,
+                :feature_name,
+                :before_feature_element,
                   :before_tags,
                   :after_tags,
-                  :feature_name,
-                  :before_feature_element,
-                    :before_tags,
-                    :after_tags,
-                    :scenario_name,
-                    :before_steps,
-                      :before_step,
-                        :before_step_result,
-                        :step_name,
-                        :after_step_result,
-                      :after_step,
-                    :after_steps,
-                  :after_feature_element,
-                :after_feature,
-                :before_feature,
+                  :scenario_name,
+                  :before_steps,
+                    :before_step,
+                      :before_step_result,
+                      :step_name,
+                      :after_step_result,
+                    :after_step,
+                  :after_steps,
+                :after_feature_element,
+              :after_feature,
+              :before_feature,
+                :before_tags,
+                :after_tags,
+                :feature_name,
+                :before_feature_element,
                   :before_tags,
                   :after_tags,
-                  :feature_name,
-                  :before_feature_element,
-                    :before_tags,
-                    :after_tags,
-                    :scenario_name,
-                    :before_steps,
-                      :before_step,
-                        :before_step_result,
-                        :step_name,
-                        :after_step_result,
-                      :after_step,
-                    :after_steps,
-                  :after_feature_element,
-                :after_feature,
-              :after_features,
+                  :scenario_name,
+                  :before_steps,
+                    :before_step,
+                      :before_step_result,
+                      :step_name,
+                      :after_step_result,
+                    :after_step,
+                  :after_steps,
+                :after_feature_element,
+              :after_feature,
+            :after_features,
           ]
         end
 
@@ -270,6 +301,41 @@ module Cucumber
           ]
         end
 
+        it 'a feature with a background and an empty scenario' do
+          execute_gherkin do
+            feature do
+              background do
+                step 'passing'
+              end
+              scenario
+            end
+          end
+          expect( formatter.legacy_messages ).to eq [
+            :before_features,
+              :before_feature,
+                :before_tags,
+                :after_tags,
+                :feature_name,
+                :before_background,
+                  :background_name,
+                  :before_steps,
+                    :before_step,
+                      :before_step_result,
+                        :step_name,
+                      :after_step_result,
+                    :after_step,
+                  :after_steps,
+                :after_background,
+                :before_feature_element,
+                  :before_tags,
+                  :after_tags,
+                  :scenario_name,
+                :after_feature_element,
+              :after_feature,
+            :after_features,
+          ]
+        end
+
         it 'a feature with a background and two scenarios' do
           execute_gherkin do
             feature do
@@ -1416,17 +1482,19 @@ module Cucumber
 
         context 'with exception in after step hook' do
 
-          class CustomMappingsWithAfterStepHook < CustomMappings
-            def test_step(test_step, mappings)
-              super
-              mappings.after { raise Failure }
+          class FailingAfterStepHook
+            def find_after_step_hooks(test_case)
+              Runtime::StepHooks.new [-> { raise Failure }]
             end
           end
 
-          let(:mappings) { CustomMappingsWithAfterStepHook.new }
-
           it 'prints the exception within the step' do
-            execute_gherkin do
+            filters = [
+              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
+              Filters::ApplyAfterStepHooks.new(FailingAfterStepHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
               feature do
                 scenario do
                   step 'passing'
@@ -1459,17 +1527,19 @@ module Cucumber
         end
 
         context 'with exception in a single before hook' do
-          class CustomMappingsWithBeforeHook < CustomMappings
-            def test_case(test_case, mappings)
-              super
-              mappings.before { raise Failure }
+          class FailingBeforeHook
+            def apply_before_hooks(test_case)
+              Runtime::BeforeHooks.new([proc { raise Failure }]).apply_to(test_case)
             end
           end
 
-          let(:mappings) { CustomMappingsWithBeforeHook.new }
-
           it 'prints the exception after the scenario name' do
-            execute_gherkin do
+            filters = [
+              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
+              Filters::ApplyBeforeHooks.new(FailingBeforeHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
               feature do
                 scenario do
                   step 'passing'
@@ -1502,13 +1572,12 @@ module Cucumber
           end
 
           it 'prints the exception after the background name' do
-            mappings = Class.new(CustomMappings) {
-              def test_case(test_case, mapper)
-                mapper.before { raise Failure }
-              end
-            }.new
-
-            execute_gherkin(mappings) do
+            filters = [
+              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
+              Filters::ApplyBeforeHooks.new(FailingBeforeHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
               feature do
                 background do
                   step 'passing'
@@ -1555,13 +1624,12 @@ module Cucumber
 
 
           it 'prints the exception before the examples table row' do
-            mappings = Class.new(CustomMappings) {
-              def test_case(test_case, mapper)
-                mapper.before { raise Failure }
-              end
-            }.new
-
-            execute_gherkin(mappings) do
+            filters = [
+              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
+              Filters::ApplyBeforeHooks.new(FailingBeforeHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
               feature do
                 scenario_outline do
                   step '<status>ing'
@@ -1618,15 +1686,19 @@ module Cucumber
         context 'with exception in the first of several before hooks' do
           # This proves that the second before hook's result doesn't overwrite
           # the result of the first one.
-          it 'prints the exception after the scenario name' do
-            mappings = Class.new(CustomMappings) {
-              def test_case(test_case, mapper)
-                mapper.before { raise Failure }
-                mapper.before { }
-              end
-            }.new
+          class FailingAndPassingBeforeHooks
+            def apply_before_hooks(test_case)
+              Runtime::BeforeHooks.new([proc { raise Failure }, proc { }]).apply_to(test_case)
+            end
+          end
 
-            execute_gherkin(mappings) do
+          it 'prints the exception after the scenario name' do
+            filters = [
+              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
+              Filters::ApplyBeforeHooks.new(FailingAndPassingBeforeHooks.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
               feature do
                 scenario do
                   step 'passing'
@@ -1660,17 +1732,20 @@ module Cucumber
         end
 
         context 'with exception in after hooks' do
-          let(:mappings) do
-            Class.new(CustomMappings) {
-              def test_case(test_case, mapper)
-                mapper.after { raise Failure }
-              end
-            }.new
+
+          class FailingAfterHook
+            def apply_after_hooks(test_case)
+              Runtime::AfterHooks.new([proc { raise Failure }]).apply_to(test_case)
+            end
           end
 
           it 'prints the exception after the steps' do
-
-            execute_gherkin(mappings) do
+            filters = [
+              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
+              Filters::ApplyAfterHooks.new(FailingAfterHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
               feature do
                 scenario do
                   step 'passing'
@@ -1703,7 +1778,12 @@ module Cucumber
           end
 
           it 'prints the exception after the examples table row' do
-            execute_gherkin do
+            filters = [
+              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
+              Filters::ApplyAfterHooks.new(FailingAfterHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
               feature do
                 scenario_outline do
                   step '<status>ing'
@@ -1758,17 +1838,19 @@ module Cucumber
         end
 
         context 'with exception in the first of several after hooks' do
-          let(:mappings) do
-            Class.new(CustomMappings) {
-              def test_case(test_case, mapper)
-                mapper.after { raise Failure }
-                mapper.after { }
-              end
-            }.new
+          class FailingThenPassingAfterHooks
+            def apply_after_hooks(test_case)
+              Runtime::AfterHooks.new([proc { raise Failure }, proc {}]).apply_to(test_case)
+            end
           end
 
           it 'prints the exception after the steps' do
-            execute_gherkin do
+            filters = [
+              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
+              Filters::ApplyAfterHooks.new(FailingThenPassingAfterHooks.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
               feature do
                 scenario do
                   step 'passing'
@@ -1802,16 +1884,13 @@ module Cucumber
         end
 
         context 'with an exception in an after hook but no steps' do
-          let(:mappings) do
-            Class.new(CustomMappings) {
-              def test_case(test_case, mapper)
-                mapper.after { raise Failure }
-              end
-            }.new
-          end
-
           it 'prints the exception after the steps' do
-            execute_gherkin do
+            filters = [
+              Filters::ActivateSteps.new(SimpleStepDefinitions.new),
+              Filters::ApplyAfterHooks.new(FailingAfterHook.new),
+              AddBeforeAndAfterHooks.new
+            ]
+            execute_gherkin(filters) do
               feature do
                 scenario do
                 end
@@ -1837,6 +1916,19 @@ module Cucumber
         end
       end
 
+      it 'passes nil as the multiline arg when there is none' do
+        expect(formatter).to receive(:after_step_result) do |keyword, step_match, multiline_arg, status, exception, source_indent, background, file_colon_line|
+          expect(multiline_arg).to be_nil
+        end
+        execute_gherkin do
+          feature do
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+      end
+
       it 'passes an object responding to failed? with the after_feature_element message' do
         expect( formatter ).to receive(:after_feature_element) do |scenario|
           expect( scenario ).to be_failed
@@ -1854,9 +1946,9 @@ module Cucumber
         let(:runtime) { Runtime.new strict: true }
 
         it 'passes an exception to the formatter for undefined steps' do
-        expect( formatter ).to receive(:exception) do |exception|
-          expect( exception.message ).to eq %{Undefined step: "this step is undefined"}
-        end
+          expect( formatter ).to receive(:exception) do |exception|
+            expect( exception.message ).to eq %{Undefined step: "this step is undefined"}
+          end
           execute_gherkin do
             feature do
               scenario do
@@ -1893,8 +1985,16 @@ module Cucumber
         end
       end
 
-      def execute_gherkin(custom_mappings = mappings, &gherkin)
-        execute [gherkin(&gherkin)], custom_mappings, report
+      def execute_gherkin(filters = default_filters, &gherkin)
+        runner = Core::Test::Runner.new(report)
+        compile [gherkin(&gherkin)], runner, filters
+      end
+
+      def default_filters
+        [
+          Filters::ActivateSteps.new(SimpleStepDefinitions.new),
+          AddBeforeAndAfterHooks.new
+        ]
       end
 
     end