cucumber 2.99.0 → 3.0.0

data/spec/cucumber/configuration_spec.rb

@@ -1,26 +1,27 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 module Cucumber
   describe Configuration do
-    describe ".default" do
+    describe '.default' do
       subject { Configuration.default }
 
-      it "has an autoload_code_paths containing the standard support and step_definitions folders" do
+      it 'has an autoload_code_paths containing the standard support and step_definitions folders' do
         expect(subject.autoload_code_paths).to include('features/support')
         expect(subject.autoload_code_paths).to include('features/step_definitions')
       end
     end
 
-    describe "with custom user options" do
+    describe 'with custom user options' do
       let(:user_options) { { :autoload_code_paths => ['foo/bar/baz'] } }
       subject { Configuration.new(user_options) }
 
-      it "allows you to override the defaults" do
+      it 'allows you to override the defaults' do
         expect(subject.autoload_code_paths).to eq ['foo/bar/baz']
       end
     end
 
-    context "selecting files to load" do
+    context 'selecting files to load' do
 
       def given_the_following_files(*files)
         allow(File).to receive(:directory?) { true }
@@ -28,114 +29,114 @@ module Cucumber
         allow(Dir).to receive(:[]) { files }
       end
 
-      it "requires env.rb files first" do
+      it 'requires env.rb files first' do
         configuration = Configuration.new
-        given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
+        given_the_following_files('/features/support/a_file.rb','/features/support/env.rb')
 
         expect(configuration.support_to_load).to eq [
-          "/features/support/env.rb",
-          "/features/support/a_file.rb"
+          '/features/support/env.rb',
+          '/features/support/a_file.rb'
         ]
       end
 
-      it "does not require env.rb files when dry run" do
+      it 'does not require env.rb files when dry run' do
         configuration = Configuration.new(dry_run: true)
-        given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
+        given_the_following_files('/features/support/a_file.rb','/features/support/env.rb')
 
         expect(configuration.support_to_load).to eq [
-          "/features/support/a_file.rb"
+          '/features/support/a_file.rb'
         ]
       end
 
-      it "requires step defs in vendor/{plugins,gems}/*/cucumber/*.rb" do
-        given_the_following_files("/vendor/gems/gem_a/cucumber/bar.rb",
-                                  "/vendor/plugins/plugin_a/cucumber/foo.rb")
+      it 'requires step defs in vendor/{plugins,gems}/*/cucumber/*.rb' do
+        given_the_following_files('/vendor/gems/gem_a/cucumber/bar.rb',
+                                  '/vendor/plugins/plugin_a/cucumber/foo.rb')
 
         configuration = Configuration.new
 
         expect(configuration.step_defs_to_load).to eq [
-          "/vendor/gems/gem_a/cucumber/bar.rb",
-          "/vendor/plugins/plugin_a/cucumber/foo.rb"
+          '/vendor/gems/gem_a/cucumber/bar.rb',
+          '/vendor/plugins/plugin_a/cucumber/foo.rb'
         ]
       end
 
-      describe "--exclude" do
+      describe '--exclude' do
 
-        it "excludes a ruby file from requiring when the name matches exactly" do
-          given_the_following_files("/features/support/a_file.rb","/features/support/env.rb")
+        it 'excludes a ruby file from requiring when the name matches exactly' do
+          given_the_following_files('/features/support/a_file.rb','/features/support/env.rb')
 
           configuration = Configuration.new(excludes: [/a_file.rb/])
 
           expect(configuration.all_files_to_load).to eq [
-            "/features/support/env.rb"
+            '/features/support/env.rb'
           ]
         end
 
-        it "excludes all ruby files that match the provided patterns from requiring" do
-          given_the_following_files("/features/support/foof.rb","/features/support/bar.rb",
-                                    "/features/support/food.rb","/features/blah.rb",
-                                    "/features/support/fooz.rb")
+        it 'excludes all ruby files that match the provided patterns from requiring' do
+          given_the_following_files('/features/support/foof.rb','/features/support/bar.rb',
+                                    '/features/support/food.rb','/features/blah.rb',
+                                    '/features/support/fooz.rb')
 
           configuration = Configuration.new(excludes: [/foo[df]/, /blah/])
 
           expect(configuration.all_files_to_load).to eq [
-            "/features/support/bar.rb",
-            "/features/support/fooz.rb"
+            '/features/support/bar.rb',
+            '/features/support/fooz.rb'
           ]
         end
       end
 
     end
 
-    context "selecting feature files" do
+    context 'selecting feature files' do
 
-      it "preserves the order of the feature files" do
+      it 'preserves the order of the feature files' do
         configuration = Configuration.new(paths: %w{b.feature c.feature a.feature})
 
-        expect(configuration.feature_files).to eq ["b.feature", "c.feature", "a.feature"]
+        expect(configuration.feature_files).to eq ['b.feature', 'c.feature', 'a.feature']
       end
 
-      it "searchs for all features in the specified directory" do
+      it 'searchs for all features in the specified directory' do
         allow(File).to receive(:directory?) { true }
-        allow(Dir).to receive(:[]).with("feature_directory/**/*.feature") { ["cucumber.feature"] }
+        allow(Dir).to receive(:[]).with('feature_directory/**/*.feature') { ['cucumber.feature'] }
 
         configuration = Configuration.new(paths: %w{feature_directory/})
 
-        expect(configuration.feature_files).to eq ["cucumber.feature"]
+        expect(configuration.feature_files).to eq ['cucumber.feature']
       end
 
-      it "defaults to the features directory when no feature file are provided" do
+      it 'defaults to the features directory when no feature file are provided' do
         allow(File).to receive(:directory?) { true }
-        allow(Dir).to receive(:[]).with("features/**/*.feature") { ["cucumber.feature"] }
+        allow(Dir).to receive(:[]).with('features/**/*.feature') { ['cucumber.feature'] }
 
         configuration = Configuration.new(paths: [])
 
-        expect(configuration.feature_files).to eq ["cucumber.feature"]
+        expect(configuration.feature_files).to eq ['cucumber.feature']
       end
 
-      it "gets the feature files from the rerun file" 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\ncucumber.feature:5 cucumber.feature:10\n"\
           "domain folder/different cuke.feature:134 domain folder/cuke.feature:1\n"\
-          "domain folder/different cuke.feature:4:5 bar.feature")
+          'domain folder/different cuke.feature:4:5 bar.feature')
 
         configuration = Configuration.new(paths: %w{@rerun.txt})
 
         expect(configuration.feature_files).to eq [
-          "cucumber.feature:1:3",
-          "cucumber.feature:5",
-          "cucumber.feature:10",
-          "domain folder/different cuke.feature:134",
-          "domain folder/cuke.feature:1",
-          "domain folder/different cuke.feature:4:5",
-          "bar.feature"]
+          'cucumber.feature:1:3',
+          'cucumber.feature:5',
+          'cucumber.feature:10',
+          'domain folder/different cuke.feature:134',
+          'domain folder/cuke.feature:1',
+          'domain folder/different cuke.feature:4:5',
+          'bar.feature']
       end
     end
 
-    describe "#with_options" do
-      it "returns a copy of the configuration with new options" do
+    describe '#with_options' do
+      it 'returns a copy of the configuration with new options' do
         old_out_stream = double('Old out_stream')
         new_out_stream = double('New out_stream')
         config = Configuration.new(out_stream: old_out_stream).with_options(out_stream: new_out_stream)

data/spec/cucumber/constantize_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'spec_helper'
 
 module Html end
@@ -6,13 +7,13 @@ module Cucumber
   describe Constantize do
     include Constantize
 
-    it "loads html formatter" do
+    it 'loads html formatter' do
       clazz = constantize('Cucumber::Formatter::Html')
 
       expect(clazz.name).to eq 'Cucumber::Formatter::Html'
     end
 
-    it "fails to load a made up class" do
+    it 'fails to load a made up class' do
       expect { constantize('My::MadeUp::ClassName') }.to raise_error(LoadError)
     end
   end

data/spec/cucumber/events_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Cucumber
+  describe Events do
+    it 'builds a registry without failing' do
+      expect { described_class.registry }.not_to raise_error
+    end
+  end
+end

data/spec/cucumber/file_specs_spec.rb

@@ -1,58 +1,59 @@
+# frozen_string_literal: true
 require 'cucumber/file_specs'
 
 module Cucumber
   describe FileSpecs do
-    let(:file_specs) { FileSpecs.new(["features/foo.feature:1:2:3", "features/bar.feature:4:5:6"]) }
+    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
+    it 'parses locations from multiple files' do
       expect(locations.length).to eq 6
       expect(locations).to eq [
-        Cucumber::Core::Ast::Location.new("features/foo.feature", 1),
-        Cucumber::Core::Ast::Location.new("features/foo.feature", 2),
-        Cucumber::Core::Ast::Location.new("features/foo.feature", 3),
-        Cucumber::Core::Ast::Location.new("features/bar.feature", 4),
-        Cucumber::Core::Ast::Location.new("features/bar.feature", 5),
-        Cucumber::Core::Ast::Location.new("features/bar.feature", 6),
+        Cucumber::Core::Ast::Location.new('features/foo.feature', 1),
+        Cucumber::Core::Ast::Location.new('features/foo.feature', 2),
+        Cucumber::Core::Ast::Location.new('features/foo.feature', 3),
+        Cucumber::Core::Ast::Location.new('features/bar.feature', 4),
+        Cucumber::Core::Ast::Location.new('features/bar.feature', 5),
+        Cucumber::Core::Ast::Location.new('features/bar.feature', 6)
       ]
     end
 
-    it "parses file names from multiple file specs" do
+    it 'parses file names from multiple file specs' do
       expect(files.length).to eq 2
       expect(files).to eq [
-        "features/foo.feature",
-        "features/bar.feature",
+        'features/foo.feature',
+        'features/bar.feature'
       ]
     end
 
-    context "when files are not unique" do
-      let(:file_specs) { FileSpecs.new(["features/foo.feature:4", "features/foo.feature:34"]) }
+    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
+      it 'parses unique file names' do
         expect(files.length).to eq 1
-        expect(files).to eq ["features/foo.feature"]
+        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"]) }
+    context 'when no line number is specified' do
+      let(:file_specs) { FileSpecs.new(['features/foo.feature', 'features/bar.feature:34']) }
 
-      it "returns a wildcard location for that file" do
+      it 'returns a wildcard location for that file' do
         expect(locations).to eq [
-          Cucumber::Core::Ast::Location.new("features/foo.feature"),
-          Cucumber::Core::Ast::Location.new("features/bar.feature", 34),
+          Cucumber::Core::Ast::Location.new('features/foo.feature'),
+          Cucumber::Core::Ast::Location.new('features/bar.feature', 34)
         ]
       end
     end
 
-    context "when the same file is referenced more than once" do
-      let(:file_specs) { FileSpecs.new(["features/foo.feature:10", "features/foo.feature:1"]) }
+    context 'when the same file is referenced more than once' do
+      let(:file_specs) { FileSpecs.new(['features/foo.feature:10', 'features/foo.feature:1']) }
 
-      it "returns locations in the order specified" do
+      it 'returns locations in the order specified' do
         expect(locations).to eq [
-          Cucumber::Core::Ast::Location.new("features/foo.feature", 10),
-          Cucumber::Core::Ast::Location.new("features/foo.feature", 1),
+          Cucumber::Core::Ast::Location.new('features/foo.feature', 10),
+          Cucumber::Core::Ast::Location.new('features/foo.feature', 1)
         ]
       end
     end

data/spec/cucumber/filters/activate_steps_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'cucumber/filters/activate_steps'
 require 'cucumber/core/gherkin/writer'
 require 'cucumber/core'
@@ -13,7 +14,7 @@ describe Cucumber::Filters::ActivateSteps do
   let(:step_match_search) { Proc.new { [step_match] } }
   let(:configuration) { double(dry_run?: false, notify: nil) }
 
-  context "a scenario with a single step" do
+  context 'a scenario with a single step' do
     let(:doc) do
       gherkin do
         feature do
@@ -24,23 +25,24 @@ describe Cucumber::Filters::ActivateSteps do
       end
     end
 
-    it "activates each step" do
+    it 'activates each step' do
       expect(step_match).to receive(:activate) do |test_step|
-        expect(test_step.name).to eq 'a passing step'
+        expect(test_step.text).to eq 'a passing step'
       end
       compile [doc], receiver, [filter]
     end
 
-    it "notifies with a StepMatch event" do
-      expect(configuration).to receive(:notify) do |event|
-        expect(event.test_step.name).to eq 'a passing step'
-        expect(event.step_match).to eq step_match
+    it 'notifies with a StepActivated event' do
+      expect(configuration).to receive(:notify) do |message, test_step, step_match|
+        expect(message).to eq :step_activated
+        expect(test_step.text).to eq 'a passing step'
+        expect(step_match).to eq step_match
       end
       compile [doc], receiver, [filter]
     end
   end
 
-  context "a scenario outline" do
+  context 'a scenario outline' do
     let(:doc) do
       gherkin do
         feature do
@@ -56,15 +58,15 @@ describe Cucumber::Filters::ActivateSteps do
       end
     end
 
-    it "activates each step" do
+    it 'activates each step' do
       expect(step_match).to receive(:activate) do |test_step|
-        expect(test_step.name).to eq 'a passing step'
+        expect(test_step.text).to eq 'a passing step'
       end
       compile [doc], receiver, [filter]
     end
   end
 
-  context "undefined step" do
+  context 'undefined step' do
     let(:step_match_search) { Proc.new { [] } }
 
     let(:doc) do
@@ -77,20 +79,20 @@ describe Cucumber::Filters::ActivateSteps do
       end
     end
 
-    it "does not activate the step" do
+    it 'does not activate the step' do
       expect(receiver).to receive(:test_case) do |test_case|
         expect(test_case.test_steps[0].execute).to be_undefined
       end
       compile [doc], receiver, [filter]
     end
 
-    it "does not notify" do
+    it 'does not notify' do
       expect(configuration).not_to receive(:notify)
       compile [doc], receiver, [filter]
     end
   end
 
-  context "dry run" do
+  context 'dry run' do
     let(:configuration) { double(dry_run?: true, notify: nil) }
 
     let(:doc) do
@@ -103,23 +105,24 @@ describe Cucumber::Filters::ActivateSteps do
       end
     end
 
-    it "activates each step with a skipping action" do
+    it 'activates each step with a skipping action' do
       expect(receiver).to receive(:test_case) do |test_case|
         expect(test_case.test_steps[0].execute).to be_skipped
       end
       compile [doc], receiver, [filter]
     end
 
-    it "notifies with a StepMatch event" do
-      expect(configuration).to receive(:notify) do |event|
-        expect(event.test_step.name).to eq 'a passing step'
-        expect(event.step_match).to eq step_match
+    it 'notifies with a StepActivated event' do
+      expect(configuration).to receive(:notify) do |message, test_step, step_match|
+        expect(message).to eq :step_activated
+        expect(test_step.text).to eq 'a passing step'
+        expect(step_match).to eq step_match
       end
       compile [doc], receiver, [filter]
     end
   end
 
-  context "undefined step in a dry run" do
+  context 'undefined step in a dry run' do
     let(:step_match_search) { Proc.new { [] } }
     let(:configuration) { double(dry_run?: true, notify: nil) }
 
@@ -133,14 +136,14 @@ describe Cucumber::Filters::ActivateSteps do
       end
     end
 
-    it "does not activate the step" do
+    it 'does not activate the step' do
       expect(receiver).to receive(:test_case) do |test_case|
         expect(test_case.test_steps[0].execute).to be_undefined
       end
       compile [doc], receiver, [filter]
     end
 
-    it "does not notify" do
+    it 'does not notify' do
       expect(configuration).not_to receive(:notify)
       compile [doc], receiver, [filter]
     end

data/spec/cucumber/filters/gated_receiver_spec.rb

@@ -1,4 +1,5 @@
-require "cucumber/filters/gated_receiver"
+# frozen_string_literal: true
+require 'cucumber/filters/gated_receiver'
 
 describe Cucumber::Filters::GatedReceiver do
   subject(:gated_receiver) { Cucumber::Filters::GatedReceiver.new(receiver) }
@@ -6,8 +7,8 @@ describe Cucumber::Filters::GatedReceiver do
   let(:receiver) { double(:receiver) }
   let(:test_cases){ [double(:test_case), double(:test_case)] }
 
-  describe "#test_case" do
-    it "does not immediately describe the test case to the receiver" do
+  describe '#test_case' do
+    it 'does not immediately describe the test case to the receiver' do
       test_cases.each do |test_case|
         expect(test_case).to_not receive(:describe_to).with(receiver)
       end
@@ -18,7 +19,7 @@ describe Cucumber::Filters::GatedReceiver do
     end
   end
 
-  describe "#done" do
+  describe '#done' do
     before do
       test_cases.each do |test_case|
         gated_receiver.test_case(test_case)
@@ -31,7 +32,7 @@ describe Cucumber::Filters::GatedReceiver do
       allow(receiver).to receive(:done)
     end
 
-    it "describes all test cases to the receiver" do
+    it 'describes all test cases to the receiver' do
       test_cases.each do |test_case|
         expect(test_case).to receive(:describe_to).with(receiver)
       end
@@ -39,7 +40,7 @@ describe Cucumber::Filters::GatedReceiver do
       gated_receiver.done
     end
 
-    it "calls done on the receiver" do
+    it 'calls done on the receiver' do
       expect(receiver).to receive(:done)
       gated_receiver.done
     end

data/spec/cucumber/filters/retry_spec.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require 'cucumber'
 require 'cucumber/filters/retry'
 require 'cucumber/core/gherkin/writer'
@@ -22,54 +23,72 @@ describe Cucumber::Filters::Retry do
   it { is_expected.to respond_to(:with_receiver) }
   it { is_expected.to respond_to(:done) }
 
-  context "general" do
-    before(:each) do
-      filter.with_receiver(receiver)
-    end
+  context 'passing test case' do
+    let(:result) { Cucumber::Core::Test::Result::Passed.new(0) }
 
-    it "registers the :after_test_case event" do
-      expect(configuration).to receive(:on_event).with(:after_test_case)
-      filter.test_case(test_case)
+    it 'describes the test case once' do
+      expect(receiver).to receive(:test_case).with(test_case).once
+      test_case.describe_to filter
+      configuration.notify :test_case_finished, test_case, result
     end
   end
 
-  context "passing test case" do
-    it "describes the test case once" do
-      expect(test_case).to receive(:describe_to).with(receiver)
+  context 'when performing retry' do
+    let(:result) { Cucumber::Core::Test::Result::Failed.new(0, StandardError.new) }
+
+    it 'describes the same test case object each time' do
+      allow(receiver).to receive(:test_case) {|tc|
+        expect(tc).to equal(test_case)
+        configuration.notify :test_case_finished, tc.with_steps(tc.test_steps), result
+      }
+
       filter.test_case(test_case)
-      configuration.notify(pass)
     end
   end
 
-  context "failing test case" do
-    it "describes the test case the specified number of times" do
+  context 'consistently failing test case' do
+    let(:result) { Cucumber::Core::Test::Result::Failed.new(0, StandardError.new) }
+
+    it 'describes the test case the specified number of times' do
       expect(receiver).to receive(:test_case) {|test_case|
-        configuration.notify(fail)
+        configuration.notify :test_case_finished, test_case, result
       }.exactly(3).times
 
       filter.test_case(test_case)
     end
   end
 
-  context "flaky test cases" do
+  context 'flaky test cases' do
+
+    context 'a little flaky' do
+      let(:results) {
+        [
+          Cucumber::Core::Test::Result::Failed.new(0, StandardError.new),
+          Cucumber::Core::Test::Result::Passed.new(0)
+        ]
+      }
 
-    context "a little flaky" do
-      it "describes the test case twice" do
-        results = [fail, pass]
+      it 'describes the test case twice' do
         expect(receiver).to receive(:test_case) {|test_case|
-          configuration.notify(results.shift)
+          configuration.notify :test_case_finished, test_case, results.shift
         }.exactly(2).times
 
         filter.test_case(test_case)
       end
     end
 
-    context "really flaky" do
-      it "describes the test case 3 times" do
-        results = [fail, fail, pass]
+    context 'really flaky' do
+      let(:results) {
+        [
+          Cucumber::Core::Test::Result::Failed.new(0, StandardError.new),
+          Cucumber::Core::Test::Result::Failed.new(0, StandardError.new),
+          Cucumber::Core::Test::Result::Passed.new(0)
+        ]
+      }
 
+      it 'describes the test case 3 times' do
         expect(receiver).to receive(:test_case) {|test_case|
-          configuration.notify(results.shift)
+          configuration.notify :test_case_finished, test_case, results.shift
         }.exactly(3).times
 
         filter.test_case(test_case)

data/spec/cucumber/filters/tag_limits/test_case_index_spec.rb

@@ -1,4 +1,5 @@
-require "cucumber/filters/tag_limits"
+# frozen_string_literal: true
+require 'cucumber/filters/tag_limits'
 
 describe Cucumber::Filters::TagLimits::TestCaseIndex do
   subject(:index) { Cucumber::Filters::TagLimits::TestCaseIndex.new }
@@ -10,8 +11,8 @@ describe Cucumber::Filters::TagLimits::TestCaseIndex do
     ]
   end
 
-  let(:tag_one) { double(:tag_one, name: "@one") }
-  let(:tag_two) { double(:tag_two, name: "@two") }
+  let(:tag_one) { double(:tag_one, name: '@one') }
+  let(:tag_two) { double(:tag_two, name: '@two') }
 
   let(:a_location_of_tag_one) { double(:a_location_of_tag_one) }
   let(:a_location_of_tag_one_and_tag_two) { double(:a_location_of_tag_one_and_tag_two) }
@@ -22,17 +23,17 @@ describe Cucumber::Filters::TagLimits::TestCaseIndex do
     end
   end
 
-  describe "#count_by_tag_name" do
-    it "returns the number of test cases with the tag" do
-      expect(index.count_by_tag_name("@one")).to eq(2)
-      expect(index.count_by_tag_name("@two")).to eq(1)
+  describe '#count_by_tag_name' do
+    it 'returns the number of test cases with the tag' do
+      expect(index.count_by_tag_name('@one')).to eq(2)
+      expect(index.count_by_tag_name('@two')).to eq(1)
     end
   end
 
-  describe "#locations_by_tag_name" do
-    it "returns the locations of test cases with the tag" do
-      expect(index.locations_of_tag_name("@one")).to eq([a_location_of_tag_one, a_location_of_tag_one_and_tag_two])
-      expect(index.locations_of_tag_name("@two")).to eq([a_location_of_tag_one_and_tag_two])
+  describe '#locations_by_tag_name' do
+    it 'returns the locations of test cases with the tag' do
+      expect(index.locations_of_tag_name('@one')).to eq([a_location_of_tag_one, a_location_of_tag_one_and_tag_two])
+      expect(index.locations_of_tag_name('@two')).to eq([a_location_of_tag_one_and_tag_two])
     end
   end
 end