cucumber-core 1.0.0.beta.4 → 1.0.0

data/lib/cucumber/core/version.rb

@@ -2,7 +2,7 @@ module Cucumber
   module Core
     class Version
       def self.to_s
-        "1.0.0.beta.4"
+        "1.0.0"
       end
     end
   end

data/spec/capture_warnings.rb

@@ -16,6 +16,11 @@ module CaptureWarnings
       print_warnings('other', other_warnings) if ENV['VIEW_OTHER_WARNINGS']
     end
 
+    # Until they fix https://bugs.ruby-lang.org/issues/10661
+    if RUBY_VERSION == "2.2.0"
+      project_warnings = project_warnings.reject { |w| w =~ /warning: possible reference to past scope/ }
+    end
+
     if project_warnings.any?
       puts "#{ project_warnings.count } cucumber-core warnings detected" 
       print_warnings('cucumber-core', project_warnings)

data/spec/cucumber/core/filter_spec.rb

@@ -0,0 +1,100 @@
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/core'
+require 'cucumber/core/filter'
+
+module Cucumber::Core
+  describe Filter do
+    include Cucumber::Core::Gherkin::Writer
+    include Cucumber::Core
+
+    describe ".new" do
+      let(:receiver) { double.as_null_object }
+
+      let(:doc) { 
+        gherkin do
+          feature do
+            scenario 'x' do
+              step 'a step'
+            end
+
+            scenario 'y' do
+              step 'a step'
+            end
+          end
+        end
+      }
+
+      it "creates a filter class that can pass-through by default" do
+        my_filter_class = Filter.new
+        my_filter = my_filter_class.new
+        expect(receiver).to receive(:test_case) { |test_case|
+          expect(test_case.test_steps.length).to eq 1
+          expect(test_case.test_steps.first.name).to eq 'a step'
+        }.exactly(2).times
+        compile [doc], receiver, [my_filter]
+      end
+
+      context "customizing by subclassing" do
+
+        # Each filter imlicitly gets a :receiver attribute
+        # that you need to call with the new test case
+        # once you've received yours and modified it.
+        class BasicBlankingFilter < Filter.new
+          def test_case(test_case)
+            test_case.with_steps([]).describe_to(receiver)
+          end
+        end
+
+        # You can pass the names of attributes when building a 
+        # filter, allowing you to have custom attributes.
+        class NamedBlankingFilter < Filter.new(:name_pattern)
+          def test_case(test_case)
+            if test_case.name =~ name_pattern
+              test_case.with_steps([]).describe_to(receiver)
+            else
+              test_case.describe_to(receiver) # or just call `super`
+            end
+            self
+          end
+        end
+
+        it "can override methods from the base class" do
+          expect(receiver).to receive(:test_case) { |test_case|
+            expect(test_case.test_steps.length).to eq 0
+          }.exactly(2).times
+          run BasicBlankingFilter.new
+        end
+
+        it "can take arguments" do
+          expect(receiver).to receive(:test_case) { |test_case|
+            expect(test_case.test_steps.length).to eq 0
+          }.once.ordered
+          expect(receiver).to receive(:test_case) { |test_case|
+            expect(test_case.test_steps.length).to eq 1
+          }.once.ordered
+          run NamedBlankingFilter.new(/x/)
+        end
+
+      end
+
+      context "customizing by using a block" do
+        BlockBlankingFilter = Filter.new do
+          def test_case(test_case)
+            test_case.with_steps([]).describe_to(receiver)
+          end
+        end
+
+        it "allows methods to be overridden" do
+          expect(receiver).to receive(:test_case) { |test_case|
+            expect(test_case.test_steps.length).to eq 0
+          }.exactly(2).times
+          run BlockBlankingFilter.new
+        end
+      end
+
+      def run(filter)
+        compile [doc], receiver, [filter]
+      end
+    end
+  end
+end

data/spec/cucumber/core/gherkin/parser_spec.rb

@@ -1,5 +1,4 @@
 # -*- encoding: utf-8 -*-
-require 'cucumber/initializer'
 require 'cucumber/core/gherkin/parser'
 require 'cucumber/core/gherkin/writer'
 

data/spec/cucumber/core/test/action_spec.rb

@@ -6,7 +6,6 @@ module Cucumber
     module Test
 
       describe Action do
-        let(:last_result) { double('last_result') }
 
         context "constructed without a block" do
           it "raises an error" do
@@ -17,51 +16,52 @@ module Cucumber
         context "executing" do
           it "executes the block passed to the constructor" do
             executed = false
-            mapping = Action.new { executed = true }
-            mapping.execute(last_result)
+            action = Action.new { executed = true }
+            action.execute
             expect( executed ).to be_truthy
           end
 
           it "returns a passed result if the block doesn't fail" do
-            mapping = Action.new {}
-            expect( mapping.execute(last_result) ).to be_passed
+            action = Action.new {}
+            expect( action.execute ).to be_passed
           end
 
           it "returns a failed result when the block raises an error" do
             exception = StandardError.new
-            mapping = Action.new { raise exception }
-            result = mapping.execute(last_result)
+            action = Action.new { raise exception }
+            result = action.execute
             expect( result ).to be_failed
             expect( result.exception ).to eq exception
           end
 
-          it "yields the last_result to the block" do
-            last_result_spy = nil
-            mapping = Action.new { |last_result| last_result_spy = last_result }
-            mapping.execute(last_result)
-            expect(last_result_spy).to eq last_result
+          it "yields the args passed to #execute to the block" do
+            args = [double, double]
+            args_spy = nil
+            action = Action.new { |arg1, arg2| args_spy = [arg1, arg2] }
+            action.execute(*args)
+            expect(args_spy).to eq args
           end
 
           it "returns a pending result if a Result::Pending error is raised" do
             exception = Result::Pending.new("TODO")
-            mapping = Action.new { raise exception }
-            result = mapping.execute(last_result)
+            action = Action.new { raise exception }
+            result = action.execute
             expect( result ).to be_pending
             expect( result.message ).to eq "TODO"
           end
 
           it "returns a skipped result if a Result::Skipped error is raised" do
             exception = Result::Skipped.new("Not working right now")
-            mapping = Action.new { raise exception }
-            result = mapping.execute(last_result)
+            action = Action.new { raise exception }
+            result = action.execute
             expect( result ).to be_skipped
             expect( result.message ).to eq "Not working right now"
           end
 
           it "returns an undefined result if a Result::Undefined error is raised" do
             exception = Result::Undefined.new("new step")
-            mapping = Action.new { raise exception }
-            result = mapping.execute(last_result)
+            action = Action.new { raise exception }
+            result = action.execute
             expect( result ).to be_undefined
             expect( result.message ).to eq "new step"
           end
@@ -75,14 +75,14 @@ module Cucumber
             end
 
             it "records the nanoseconds duration of the execution on the result" do
-              mapping = Action.new { }
-              duration = mapping.execute(last_result).duration
+              action = Action.new { }
+              duration = action.execute.duration
               expect( duration ).to be_duration 1
             end
 
             it "records the duration of a failed execution" do
-              mapping = Action.new { raise StandardError }
-              duration = mapping.execute(last_result).duration
+              action = Action.new { raise StandardError }
+              duration = action.execute.duration
               expect( duration ).to be_duration 1
             end
           end
@@ -92,35 +92,33 @@ module Cucumber
         context "skipping" do
           it "does not execute the block" do
             executed = false
-            mapping = Action.new { executed = true }
-            mapping.skip(last_result)
+            action = Action.new { executed = true }
+            action.skip
             expect( executed ).to be_falsey
           end
 
           it "returns a skipped result" do
-            mapping = Action.new {}
-            expect( mapping.skip(last_result) ).to be_skipped
+            action = Action.new {}
+            expect( action.skip ).to be_skipped
           end
         end
       end
 
       describe UndefinedAction do
-        let(:mapping) { UndefinedAction.new }
+        let(:action) { UndefinedAction.new }
         let(:test_step) { double }
-        let(:last_result) { double('last_result') }
 
         context "executing" do
           it "returns an undefined result" do
-            expect( mapping.execute(last_result) ).to be_undefined
+            expect( action.execute ).to be_undefined
           end
         end
 
         context "skipping" do
           it "returns an undefined result" do
-            expect( mapping.skip(last_result) ).to be_undefined
+            expect( action.skip ).to be_undefined
           end
         end
-
       end
 
     end

data/spec/cucumber/core/test/runner_spec.rb

@@ -10,10 +10,10 @@ module Cucumber::Core::Test
     let(:source)    { double }
     let(:runner)    { Runner.new(report) }
     let(:report)    { double.as_null_object }
-    let(:passing)   { Step.new([double]).with_mapping {} }
-    let(:failing)   { Step.new([double]).with_mapping { raise exception } }
-    let(:pending)   { Step.new([double]).with_mapping { raise Result::Pending.new("TODO") } }
-    let(:skipping)  { Step.new([double]).with_mapping { raise Result::Skipped.new } }
+    let(:passing)   { Step.new([double]).with_action {} }
+    let(:failing)   { Step.new([double]).with_action { raise exception } }
+    let(:pending)   { Step.new([double]).with_action { raise Result::Pending.new("TODO") } }
+    let(:skipping)  { Step.new([double]).with_action { raise Result::Skipped.new } }
     let(:undefined) { Step.new([double]) }
     let(:exception) { StandardError.new('test error') }
 
@@ -203,7 +203,7 @@ module Cucumber::Core::Test
           result_spy = last_result
         end
         after_hook = Step.new([double], hook_mapping)
-        failing_step = Step.new([double]).with_mapping { fail }
+        failing_step = Step.new([double]).with_action { fail }
         test_case = Case.new([failing_step, after_hook], source)
         test_case.describe_to runner
         expect(result_spy).to be_failed

data/spec/cucumber/core/test/step_spec.rb

@@ -2,7 +2,6 @@ require 'cucumber/core/test/step'
 
 module Cucumber::Core::Test
   describe Step do
-    let(:last_result) { double('last_result') }
 
     describe "describing itself" do
       it "describes itself to a visitor" do
@@ -28,28 +27,38 @@ module Cucumber::Core::Test
     describe "executing" do
       let(:ast_step) { double }
 
-      context "when a passing mapping exists" do
+      it "passes arbitrary arguments to the action's block" do
+        args_spy = nil
+        expected_args = [double, double]
+        test_step = Step.new([ast_step]).with_action do |*actual_args|
+          args_spy = actual_args
+        end
+        test_step.execute(*expected_args)
+        expect(args_spy).to eq expected_args
+      end
+
+      context "when a passing action exists" do
         it "returns a passing result" do
-          test_step = Step.new([ast_step]).with_mapping {}
-          expect( test_step.execute(last_result) ).to be_passed
+          test_step = Step.new([ast_step]).with_action {}
+          expect( test_step.execute ).to be_passed
         end
       end
 
-      context "when a failing mapping exists" do
+      context "when a failing action exists" do
         let(:exception) { StandardError.new('oops') }
 
         it "returns a failing result" do
-          test_step = Step.new([ast_step]).with_mapping { raise exception }
-          result = test_step.execute(last_result)
+          test_step = Step.new([ast_step]).with_action { raise exception }
+          result = test_step.execute
           expect( result           ).to be_failed
           expect( result.exception ).to eq exception
         end
       end
 
-      context "with no mapping" do
+      context "with no action" do
         it "returns an Undefined result" do
           test_step = Step.new([ast_step])
-          result = test_step.execute(last_result)
+          result = test_step.execute
           expect( result           ).to be_undefined
         end
       end

data/spec/cucumber/core_spec.rb

@@ -1,8 +1,10 @@
 require 'report_api_spy'
 require 'cucumber/core'
+require 'cucumber/core/filter'
 require 'cucumber/core/gherkin/writer'
 require 'cucumber/core/platform'
 require 'cucumber/core/report/summary'
+require 'cucumber/core/test/around_hook'
 
 module Cucumber
   describe Core do
@@ -71,7 +73,7 @@ module Cucumber
           end
         end
 
-        compile [gherkin], visitor, [[Cucumber::Core::Test::TagFilter, [['@a', '@b']]]]
+        compile [gherkin], visitor, [Cucumber::Core::Test::TagFilter.new(['@a', '@b'])]
       end
 
       describe 'with tag filters that have limits' do
@@ -114,7 +116,7 @@ module Cucumber
 
         context 'on scenarios' do
           let(:tag_filters) {
-            [[Cucumber::Core::Test::TagFilter, [['@one:1']]]]
+            [ Cucumber::Core::Test::TagFilter.new(['@one:1']) ]
           }
 
           it 'raises a tag excess error with the location of the test cases' do
@@ -128,7 +130,7 @@ module Cucumber
 
         context 'on scenario outlines' do
           let(:tag_filters) {
-            [[Cucumber::Core::Test::TagFilter, [['@three:1']]]]
+            [ Cucumber::Core::Test::TagFilter.new(['@three:1']) ]
           }
 
           it 'raises a tag excess error with the location of the test cases' do
@@ -142,7 +144,7 @@ module Cucumber
 
         context 'on a feature with scenarios' do
           let(:tag_filters) {
-            [[Cucumber::Core::Test::TagFilter, [['@feature:2']]]]
+            [ Cucumber::Core::Test::TagFilter.new(['@feature:2']) ]
           }
 
           it 'raises a tag excess error with the location of the test cases' do
@@ -158,7 +160,7 @@ module Cucumber
 
         context 'with negated tags' do
           let(:tag_filters) {
-            [[Cucumber::Core::Test::TagFilter, [['~@one:1']]]]
+            [ Cucumber::Core::Test::TagFilter.new(['~@one:1']) ]
           }
 
           it 'raises a tag excess error with the location of the test cases' do
@@ -172,7 +174,7 @@ module Cucumber
 
         context 'whith multiple tag limits' do
           let(:tag_filters) {
-            [[Cucumber::Core::Test::TagFilter, [['@one:1, @three:1', '~@feature:3']]]]
+            [ Cucumber::Core::Test::TagFilter.new(['@one:1, @three:1', '~@feature:3']) ]
           }
 
           it 'raises a tag excess error with the location of the test cases' do
@@ -198,17 +200,20 @@ module Cucumber
 
     describe "executing a test suite" do
       context "without hooks" do
-        class StepTestMappings
-          Failure = Class.new(StandardError)
-
-          def test_case(test_case, mapper)
-            self
-          end
+        class WithSteps < Core::Filter.new
+          def test_case(test_case)
+            test_steps = test_case.test_steps.map do |step|
+              case step.name
+              when /fail/
+                step.with_action { raise Failure }
+              when /pass/
+                step.with_action {}
+              else
+                step
+              end
+            end
 
-          def test_step(step, mapper)
-            mapper.map { raise Failure } if step.name =~ /fail/
-            mapper.map {}                if step.name =~ /pass/
-            self
+            test_case.with_steps(test_steps).describe_to(receiver)
           end
         end
 
@@ -228,9 +233,8 @@ module Cucumber
             end
           end
           report = Core::Report::Summary.new
-          mappings = StepTestMappings.new
 
-          execute [gherkin], mappings, report
+          execute [gherkin], report, [WithSteps.new]
 
           expect( report.test_cases.total           ).to eq 2
           expect( report.test_cases.total_passed    ).to eq 1
@@ -243,149 +247,22 @@ module Cucumber
         end
       end
 
-      context "with hooks" do
-        class HookTestMappings
-          Failure = Class.new(StandardError)
-          attr_reader :logger
-
-          def initialize
-            @logger = []
-          end
-
-          def test_case(test_case, mapper)
-            mapper.before { @logger << ['--'] }
-            failing_before = proc do
-              @logger << [:failing_before, test_case.name]
-              raise Failure
-            end
-            passing_after = proc do
-              @logger << [:passing_after, test_case.name]
-            end
-            passing_before = proc do 
-              @logger << [:passing_before, test_case.name]
-            end
-            failing_after = proc do
-              @logger << [:failing_after, test_case.name]
-              raise Failure
-            end
-
-            case test_case.name
-
-            when /fail before/
-              mapper.before( &failing_before )
-              mapper.after( &passing_after )
-
-            when /fail after/
-              mapper.before( &passing_before )
-              mapper.after( &failing_after )
-
-            else
-              mapper.before( &passing_before )
-              mapper.after( &passing_after )
-
-            end
-
-            self
-          end
-
-          def test_step(test_step, mapper)
-            mapper.map { @logger << [:step, test_step.name] } # all steps pass
-            if test_step.name == 'fail after'
-              mapper.after do
-                @logger << :failing_after_step
-                raise Failure 
-              end
-            end
-            self
-          end
-        end
-
-        it "executes the steps and hooks in the right order" do
-          gherkin = gherkin do
-            feature do
-              scenario 'fail before' do
-                step 'passing'
-              end
-
-              scenario 'fail after' do
-                step 'passing'
-              end
-
-              scenario 'fail step' do
-                step 'fail after'
-              end
-
-              scenario 'passing' do
-                step 'passing'
-              end
-            end
-          end
-          report = Core::Report::Summary.new
-          mappings = HookTestMappings.new
-
-          execute [gherkin], mappings, report
-
-          expect( report.test_steps.total        ).to eq(17)
-          expect( report.test_steps.total_failed ).to eq(3)
-          expect( report.test_cases.total        ).to eq(4)
-          expect( report.test_cases.total_passed ).to eq(1)
-          expect( report.test_cases.total_failed ).to eq(3)
-          expect( mappings.logger ).to eq [
-            ["--"], 
-            [:failing_before, "Scenario: fail before"], 
-            [:passing_after, "Scenario: fail before"],
-            ["--"], 
-            [:passing_before, "Scenario: fail after"], 
-            [:step, "passing"],
-            [:failing_after, "Scenario: fail after"],
-            ["--"],
-            [:passing_before, "Scenario: fail step"],
-            [:step, "fail after"],
-            :failing_after_step,
-            [:passing_after, "Scenario: fail step"],
-            ["--"],
-            [:passing_before, "Scenario: passing"],
-            [:step, "passing"],
-            [:passing_after, "Scenario: passing"]
-          ]
-        end
-      end
-
       context "with around hooks" do
-        class AroundHookTestMappings
-          attr_reader :logger
-
-          def initialize
-            @logger = []
-          end
-
-          def test_case(test_case, mapper)
-            logger = @logger
-            mapper.around do |run_scenario|
+        class WithAroundHooks < Core::Filter.new(:logger)
+          def test_case(test_case)
+            base_step = Core::Test::Step.new(test_case.source)
+            test_steps = [
+              base_step.with_action { logger << :step },
+            ]
+
+            around_hook = Core::Test::AroundHook.new do |run_scenario|
               logger << :before_all
               run_scenario.call
               logger << :middle
               run_scenario.call
               logger << :after_all
             end
-            mapper.before do
-              logger << :before
-            end
-            mapper.after do
-              logger << :after
-            end
-            self
-          end
-
-          def test_step(step, mapper)
-            logger = @logger
-            mapper.map do
-              logger << :during
-            end
-            mapper.after do
-              logger << :after_step
-            end
-            self
+            test_case.with_steps(test_steps).with_around_hooks([around_hook]).describe_to(receiver)
           end
         end
 
@@ -398,24 +275,18 @@ module Cucumber
             end
           end
           report = Core::Report::Summary.new
-          mappings = AroundHookTestMappings.new
+          logger = []
 
-          execute [gherkin], mappings, report
+          execute [gherkin], report, [WithAroundHooks.new(logger)]
 
           expect( report.test_cases.total        ).to eq 1
           expect( report.test_cases.total_passed ).to eq 1
           expect( report.test_cases.total_failed ).to eq 0
-          expect( mappings.logger ).to eq [
+          expect( logger ).to eq [
             :before_all, 
-              :before, 
-                :during, 
-                :after_step, 
-              :after, 
+              :step, 
             :middle, 
-              :before,
-                :during, 
-                :after_step, 
-              :after,
+              :step, 
             :after_all
           ]
         end
@@ -439,9 +310,8 @@ module Cucumber
           end
         end
         report = Core::Report::Summary.new
-        mappings = HookTestMappings.new
 
-        execute [gherkin], mappings, report, [[Cucumber::Core::Test::TagFilter, ['@a']]]
+        execute [gherkin], report, [ Cucumber::Core::Test::TagFilter.new(['@a']) ]
 
         expect( report.test_cases.total ).to eq 2
       end
@@ -458,9 +328,8 @@ module Cucumber
           end
         end
         report = Core::Report::Summary.new
-        mappings = HookTestMappings.new
 
-        execute [gherkin], mappings, report, [[Cucumber::Core::Test::NameFilter, [[/scenario/]]]]
+        execute [gherkin], report, [ Cucumber::Core::Test::NameFilter.new([/scenario/]) ]
 
         expect( report.test_cases.total ).to eq 1
       end
@@ -483,11 +352,10 @@ module Cucumber
         end
 
         report = Core::Report::Summary.new
-        mappings = HookTestMappings.new
         some_feature = Cucumber::Core::Ast::Location.new("some.feature")
-        filters = [[ Cucumber::Core::Test::LocationsFilter, [[some_feature]] ]]
+        filters = [ Cucumber::Core::Test::LocationsFilter.new([some_feature]) ]
 
-        execute documents, mappings, report, filters
+        execute documents, report, filters
 
         expect( report.test_cases.total ).to eq 1
       end