cucumber-core 10.1.1 → 11.1.0

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

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core'
-require 'cucumber/core/gherkin/writer'
-require 'cucumber/core/platform'
-require 'cucumber/core/test/case'
-require 'unindent'
-
-module Cucumber
-  module Core
-    module Test
-      describe Case do
-        include Core
-        include Core::Gherkin::Writer
-
-        let(:id) { double }
-        let(:name) { double }
-        let(:location) { double }
-        let(:tags) { double }
-        let(:language) { double }
-        let(:test_case) { Test::Case.new(id, name, test_steps, location, tags, language) }
-        let(:test_steps) { [double, double] }
-
-        context 'describing itself' do
-          it "describes itself to a visitor" do
-            visitor = double
-            args = double
-            expect(visitor).to receive(:test_case).with(test_case, args)
-            test_case.describe_to(visitor, args)
-          end
-
-          it "asks each test_step to describe themselves to the visitor" do
-            visitor = double
-            args = double
-            test_steps.each do |test_step|
-              expect(test_step).to receive(:describe_to).with(visitor, args)
-            end
-            allow(visitor).to receive(:test_case).and_yield(visitor)
-            test_case.describe_to(visitor, args)
-          end
-
-          it "describes around hooks in order" do
-            visitor = double
-            allow(visitor).to receive(:test_case).and_yield(visitor)
-            first_hook = double
-            second_hook = double
-            expect(first_hook).to receive(:describe_to).ordered.and_yield
-            expect(second_hook).to receive(:describe_to).ordered.and_yield
-            around_hooks = [first_hook, second_hook]
-            Test::Case.new(id, name, [], location, tags, language, around_hooks).describe_to(visitor, double)
-          end
-        end
-
-        describe "#name" do
-          it "the name is passed when creating the test case" do
-            expect(test_case.name).to eq(name)
-          end
-        end
-
-        describe "#location" do
-          it "the location is passed when creating the test case" do
-            expect(test_case.location).to eq(location)
-          end
-        end
-
-        describe "#tags" do
-          it "the tags are passed when creating the test case" do
-            expect(test_case.tags).to eq(tags)
-          end
-        end
-
-        describe "matching tags" do
-          let(:tags) { ['@a', '@b', '@c'].map { |value| Tag.new(location, value) } }
-          it "matches tags using tag expressions" do
-            expect(test_case.match_tags?(['@a and @b'])).to be_truthy
-            expect(test_case.match_tags?(['@a or @d'])).to be_truthy
-            expect(test_case.match_tags?(['not @d'])).to be_truthy
-            expect(test_case.match_tags?(['@a and @d'])).to be_falsy
-          end
-
-          it "matches handles multiple expressions" do
-            expect(test_case.match_tags?(['@a and @b', 'not @d'])).to be_truthy
-            expect(test_case.match_tags?(['@a and @b', 'not @c'])).to be_falsy
-          end
-        end
-
-        describe "matching names" do
-          let(:name) { 'scenario' }
-          it "matches names against regexp" do
-            expect(test_case.match_name?(/scenario/)).to be_truthy
-          end
-        end
-
-        describe "#language" do
-          let(:language) { 'en-pirate' }
-          it "the language is passed when creating the test case" do
-            expect(test_case.language).to eq 'en-pirate'
-          end
-        end
-
-        describe "equality" do
-          it "is equal to another test case at the same location" do
-            gherkin = gherkin('features/foo.feature') do
-              feature do
-                scenario do
-                  step 'text'
-                end
-              end
-            end
-            test_case_instances = []
-            receiver = double.as_null_object
-            allow(receiver).to receive(:test_case) do |test_case|
-              test_case_instances << test_case
-            end
-            2.times { compile([gherkin], receiver) }
-            expect(test_case_instances.length).to eq 2
-            expect(test_case_instances.uniq.length).to eq 1
-            expect(test_case_instances[0]).to be_eql test_case_instances[1]
-            expect(test_case_instances[0]).to eq test_case_instances[1]
-            expect(test_case_instances[0]).not_to equal test_case_instances[1]
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-require 'cucumber/core/test/data_table'
-
-module Cucumber
-  module Core
-    module Test
-      describe DataTable do
-        before do
-          @table = DataTable.new([
-            %w{one four seven},
-            %w{4444 55555 666666}
-          ])
-        end
-
-        describe "equality" do
-          it "is equal to another table with the same data" do
-            expect( DataTable.new([[1, 2], [3, 4]]) ).to eq DataTable.new([[1, 2], [3, 4]])
-          end
-
-          it "is not equal to another table with different data" do
-            expect( DataTable.new([[1, 2], [3, 4]]) ).not_to eq DataTable.new([[1, 2]])
-          end
-
-          it "is not equal to a non table" do
-            expect( DataTable.new([[1, 2], [3, 4]]) ).not_to eq Object.new
-          end
-        end
-
-        describe "#data_table?" do
-          let(:table) { DataTable.new([[1, 2], [3, 4]]) }
-
-          it "returns true" do
-            expect(table).to be_data_table
-          end
-        end
-
-        describe "#doc_string" do
-          let(:table) { DataTable.new([[1, 2], [3, 4]]) }
-
-          it "returns false" do
-            expect(table).not_to be_doc_string
-          end
-        end
-
-        describe "#map" do
-          let(:table) { DataTable.new([ %w{foo bar}, %w{1 2} ]) }
-
-          it 'yields the contents of each cell to the block' do
-
-            expect { |b| table.map(&b) }.to yield_successive_args('foo', 'bar', '1', '2')
-          end
-
-          it 'returns a new table with the cells modified by the block' do
-            expect( table.map { |cell| "*#{cell}*" } ).to eq DataTable.new([%w{*foo* *bar*}, %w{*1* *2*}])
-          end
-        end
-
-        describe "#transpose" do
-          before(:each) do
-            @table = DataTable.new([
-              %w{one 1111},
-              %w{two 22222}
-            ])
-          end
-
-          it "should transpose the table" do
-            transposed = DataTable.new([
-              %w{one two},
-              %w{1111 22222}
-            ])
-            expect( @table.transpose ).to eq( transposed )
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/test/doc_string'
-require 'unindent'
-
-module Cucumber
-  module Core
-    module Test
-      describe DocString do
-        let(:doc_string) { DocString.new(content, content_type) }
-
-        describe "#data_table?" do
-          let(:doc_string) { DocString.new("test", "text/plain" ) }
-
-          it "returns false" do
-            expect(doc_string).not_to be_data_table
-          end
-        end
-
-        describe "#doc_string" do
-          let(:doc_string) { DocString.new("test", "text/plain" ) }
-
-          it "returns true" do
-            expect(doc_string).to be_doc_string
-          end
-        end
-
-        context '#map' do
-          let(:content) { 'original content' }
-          let(:content_type) { double }
-
-          it 'yields with the content' do
-            expect { |b| doc_string.map(&b) }.to yield_with_args(content)
-          end
-
-          it 'returns a new docstring with new content' do
-            expect( doc_string.map { 'foo' }.content ).to eq 'foo'
-          end
-
-          it 'raises an error if no block is given' do
-            expect { doc_string.map }.to raise_error ArgumentError
-          end
-        end
-
-        context 'equality' do
-          let(:content) { 'foo' }
-          let(:content_type) { 'text/plain' }
-
-          it 'is equal to another DocString with the same content and content_type' do
-            expect( doc_string ).to eq DocString.new(content, content_type)
-          end
-
-          it 'is not equal to another DocString with different content' do
-            expect( doc_string ).not_to eq DocString.new('bar', content_type)
-          end
-
-          it 'is not equal to another DocString with different content_type' do
-            expect( doc_string ).not_to eq DocString.new(content, 'text/html')
-          end
-
-          it 'is equal to a string with the same content' do
-            expect( doc_string ).to eq 'foo'
-          end
-
-          it 'returns false when compared with something odd' do
-            expect( doc_string ).not_to eq 5
-          end
-        end
-
-        context 'quacking like a String' do
-          let(:content) { String.new('content') }
-          let(:content_type) { 'text/plain' }
-
-          it 'delegates #encoding to the content string' do
-            content.force_encoding('us-ascii')
-            expect( doc_string.encoding ).to eq Encoding.find('US-ASCII')
-          end
-
-          it 'allows implicit conversion to a String' do
-            expect( 'expected content' ).to include(doc_string)
-          end
-
-          it 'allows explicit conversion to a String' do
-            expect( doc_string.to_s ).to eq 'content'
-          end
-
-          it 'delegates #gsub to the content string' do
-            expect( doc_string.gsub(/n/, '_') ).to eq 'co_te_t'
-          end
-
-          it 'delegates #split to the content string' do
-            expect(doc_string.split('n')).to eq ['co', 'te', 't']
-          end
-        end
-      end
-
-      context "inspect" do
-        let(:content_type) { 'text/plain' }
-
-        it "provides a useful inspect method" do
-          doc_string = DocString.new("some text", content_type)
-          expect(doc_string.inspect).to eq <<-END.chomp.unindent
-          #<Cucumber::Core::Test::DocString
-            """text/plain
-            some text
-            """>
-          END
-        end
-      end
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-# -*- encoding: utf-8 -*-
-# frozen_string_literal: true
-require 'cucumber/core/test/result'
-require 'rspec/expectations'
-
-module Cucumber::Core::Test
-  RSpec::Matchers.define :be_duration do |expected|
-    match do |actual|
-      actual.tap { |duration| @nanoseconds = duration.nanoseconds }
-      @nanoseconds == expected
-    end
-  end
-
-  RSpec::Matchers.define :an_unknown_duration do
-    match do |actual|
-      actual.tap { raise "#tap block was executed, not an UnknownDuration" }
-      expect(actual).to respond_to(:nanoseconds)
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/test/location'
-require 'cucumber/core/test/empty_multiline_argument'
-
-module Cucumber
-  module Core
-    module Test
-      describe EmptyMultilineArgument do
-
-        let(:location) { double }
-        let(:arg) { EmptyMultilineArgument.new }
-
-        describe "#data_table?" do
-          it "returns false" do
-            expect(arg).not_to be_data_table
-          end
-        end
-
-        describe "#doc_string" do
-          it "returns false" do
-            expect(arg).not_to be_doc_string
-          end
-        end
-
-      end
-    end
-  end
-end

data/spec/cucumber/core/test/filters/locations_filter_spec.rb

@@ -1,271 +0,0 @@
-# encoding: utf-8
-# frozen_string_literal: true
-require 'cucumber/core/gherkin/writer'
-require 'cucumber/core'
-require 'cucumber/core/test/filters/locations_filter'
-require 'timeout'
-require 'cucumber/core/test/location'
-
-module Cucumber::Core
-  describe Test::LocationsFilter do
-    include Cucumber::Core::Gherkin::Writer
-    include Cucumber::Core
-
-    let(:receiver) { SpyReceiver.new }
-
-    let(:doc) do
-      gherkin('features/test.feature') do
-        feature do
-          scenario 'x' do
-            step 'a step'
-          end
-
-          scenario 'y' do
-            step 'a step'
-          end
-        end
-      end
-    end
-
-    it "sorts by the given locations" do
-      locations = [
-        Test::Location.new('features/test.feature', 6),
-        Test::Location.new('features/test.feature', 3)
-      ]
-      filter = Test::LocationsFilter.new(locations)
-      compile [doc], receiver, [filter]
-      expect(receiver.test_case_locations).to eq locations
-    end
-
-    it "works with wildcard locations" do
-      locations = [
-        Test::Location.new('features/test.feature')
-      ]
-      filter = Test::LocationsFilter.new(locations)
-      compile [doc], receiver, [filter]
-      expect(receiver.test_case_locations).to eq [
-        Test::Location.new('features/test.feature', 3),
-        Test::Location.new('features/test.feature', 6)
-      ]
-    end
-
-    it "filters out scenarios that don't match" do
-      locations = [
-        Test::Location.new('features/test.feature', 3)
-      ]
-      filter = Test::LocationsFilter.new(locations)
-      compile [doc], receiver, [filter]
-      expect(receiver.test_case_locations).to eq locations
-    end
-
-    describe "matching location" do
-      let(:file) { 'features/path/to/the.feature' }
-
-      let(:test_cases) do
-        receiver = double.as_null_object
-        result = []
-        allow(receiver).to receive(:test_case) { |test_case| result << test_case }
-        compile [doc], receiver
-        result
-      end
-
-      context "for a scenario" do
-        let(:doc) do
-          Gherkin::Document.new(file, <<-END)
-            Feature:
-
-              Scenario: one
-                Given one a
-
-              # comment
-              @tags
-              Scenario: two
-                Given two a
-                And two b
-
-              Scenario: three
-                Given three b
-
-              Scenario: with docstring
-                Given a docstring
-                  """
-                  this is a docstring
-                  """
-
-              Scenario: with a table
-                Given a table
-                  | a | b |
-                  | 1 | 2 |
-                  | 3 | 4 |
-
-          END
-        end
-
-        def test_case_named(name)
-          test_cases.find { |c| c.name == name }
-        end
-
-        it 'matches the precise location of the scenario' do
-          location = test_case_named('two').location
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq [test_case_named('two').location]
-        end
-
-        it 'matches multiple locations' do
-          good_location = Test::Location.new(file, 8)
-          bad_location = Test::Location.new(file, 5)
-          filter = Test::LocationsFilter.new([good_location, bad_location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq [test_case_named('two').location]
-        end
-
-        it "doesn't match a location after the scenario line" do
-          location = Test::Location.new(file, 9)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq []
-        end
-
-        it "doesn't match a location before the scenario line" do
-          location = Test::Location.new(file, 7)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq []
-        end
-
-        context "with duplicate locations in the filter" do
-          it "matches each test case only once" do
-            location_tc_two = test_case_named('two').location
-            location_tc_one = test_case_named('one').location
-            location_last_step_tc_two = Test::Location.new(file, 10)
-            filter = Test::LocationsFilter.new([location_tc_two, location_tc_one, location_last_step_tc_two])
-            compile [doc], receiver, [filter]
-            expect(receiver.test_case_locations).to eq [test_case_named('two').location, location_tc_one = test_case_named('one').location]
-          end
-        end
-      end
-
-      context "for a scenario outline" do
-        let(:doc) do
-          Gherkin::Document.new(file, <<-END)
-            Feature:
-
-              Scenario: one
-                Given one a
-
-              # comment on line 6
-              @tags-on-line-7
-              Scenario Outline: two <arg>
-                Given two a
-                And two <arg>
-                  """
-                  docstring
-                  """
-
-                # comment on line 15
-                @tags-on-line-16
-                Examples: x1
-                  | arg |
-                  | b   |
-
-                Examples: x2
-                  | arg |
-                  | c   |
-                  | d   |
-
-              Scenario: three
-                Given three b
-          END
-        end
-
-        let(:test_case) do
-          test_cases.find { |c| c.name == "two b" }
-        end
-
-        it "matches row location to the test case of the row" do
-          locations = [
-            Test::Location.new(file, 19),
-          ]
-          filter = Test::LocationsFilter.new(locations)
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq [test_case.location]
-        end
-
-        it "matches outline location with the all test cases of all the tables" do
-          locations = [
-            Test::Location.new(file, 8),
-          ]
-          filter = Test::LocationsFilter.new(locations)
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations.map(&:line)).to eq [19, 23, 24]
-        end
-
-        it "doesn't match the location of the examples line" do
-          location = Test::Location.new(file, 17)
-          filter = Test::LocationsFilter.new([location])
-          compile [doc], receiver, [filter]
-          expect(receiver.test_case_locations).to eq []
-        end
-      end
-    end
-
-    context "under load", slow: true do
-      num_features = 50
-      num_scenarios_per_feature = 50
-
-      let(:docs) do
-        (1..num_features).map do |i|
-          gherkin("features/test_#{i}.feature") do
-            feature do
-              (1..num_scenarios_per_feature).each do |j|
-                scenario "scenario #{j}" do
-                  step 'text'
-                end
-              end
-            end
-          end
-        end
-      end
-
-      num_locations = num_features
-      let(:locations) do
-        (1..num_locations).map do |i|
-          (1..num_scenarios_per_feature).map do |j|
-            line = 3 + ((j - 1) * 3)
-            Test::Location.new("features/test_#{i}.feature", line)
-          end
-        end.flatten
-      end
-
-      max_duration_ms = 10000
-      max_duration_ms *= 2.5 if defined?(JRUBY_VERSION)
-      it "filters #{num_features * num_scenarios_per_feature} test cases within #{max_duration_ms}ms" do
-        filter = Test::LocationsFilter.new(locations)
-        Timeout.timeout(max_duration_ms / 1000.0) do
-          compile docs, receiver, [filter]
-        end
-        expect(receiver.test_cases.length).to eq num_features * num_scenarios_per_feature
-      end
-
-    end
-  end
-
-  class SpyReceiver
-    def test_case(test_case)
-      test_cases << test_case
-    end
-
-    def done
-    end
-
-    def test_case_locations
-      test_cases.map(&:location)
-    end
-
-    def test_cases
-      @test_cases ||= []
-    end
-
-  end
-end