cucumber-core 4.0.0 → 5.0.0

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

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+require 'cucumber/core/test/location'
+require 'cucumber/core/test/doc_string'
+require 'unindent'
+
+module Cucumber
+  module Core
+    module Test
+      describe DocString do
+        let(:location) { double }
+        let(:doc_string) { DocString.new(content, content_type, location) }
+
+        describe "#data_table?" do
+          let(:doc_string) { DocString.new("test", "text/plain" , location) }
+
+          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" , location) }
+
+          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, location)
+          end
+
+          it 'is not equal to another DocString with different content' do
+            expect( doc_string ).not_to eq DocString.new('bar', content_type, location)
+          end
+
+          it 'is not equal to another DocString with different content_type' do
+            expect( doc_string ).not_to eq DocString.new(content, 'text/html', location)
+          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(:location) { Test::Location.new("features/feature.feature", 8) }
+        let(:content_type) { 'text/plain' }
+
+        it "provides a useful inspect method" do
+          doc_string = DocString.new("some text", content_type, location)
+          expect(doc_string.inspect).to eq <<-END.chomp.unindent
+          #<Cucumber::Core::Test::DocString (features/feature.feature:8)
+            """text/plain
+            some text
+            """>
+          END
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# -*- 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

@@ -0,0 +1,28 @@
+# 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

@@ -0,0 +1,271 @@
+# 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 = 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

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+require 'cucumber/core/test/location'
+
+module Cucumber::Core::Test
+  RSpec::Matchers.define :be_included_in do |expected|
+    match do |actual|
+      expected.include? actual
+    end
+  end
+
+  describe Location do
+    let(:line) { 12 }
+    let(:file) { "foo.feature" }
+
+    describe "equality" do
+      it "is equal to another Location on the same line of the same file" do
+        one_location = Location.new(file, line)
+        another_location = Location.new(file, line)
+        expect( one_location ).to eq another_location
+      end
+
+       it "is not equal to a wild card of the same file" do
+         expect( Location.new(file, line) ).not_to eq Location.new(file)
+       end
+
+      context "collections of locations" do
+        it "behave as expected with uniq" do
+          unique_collection = [Location.new(file, line), Location.new(file, line)].uniq
+          expect( unique_collection ).to eq [Location.new(file, line)]
+        end
+      end
+    end
+
+    describe "to_s" do
+      it "is file:line for a precise location" do
+        expect( Location.new("foo.feature", 12).to_s ).to eq "foo.feature:12"
+      end
+
+      it "is file for a wildcard location" do
+        expect( Location.new("foo.feature").to_s ).to eq "foo.feature"
+      end
+
+      it "is file:first_line..last_line for a ranged location" do
+        expect( Location.new("foo.feature", 13..19).to_s ).to eq "foo.feature:13..19"
+      end
+
+      it "is file:line:line:line for an arbitrary set of lines" do
+        expect( Location.new("foo.feature", [1,3,5]).to_s ).to eq "foo.feature:1:3:5"
+      end
+    end
+
+    describe "matches" do
+      let(:matching) { Location.new(file, line) }
+      let(:same_file_other_line) { Location.new(file, double) }
+      let(:not_matching) { Location.new(other_file, line) }
+      let(:other_file) { double }
+
+      context 'a precise location' do
+        let(:precise) { Location.new(file, line) }
+
+        it "matches a precise location of the same file and line" do
+          expect( matching ).to be_match(precise)
+        end
+
+        it "does not match a precise location on a different line in the same file" do
+          expect( matching ).not_to be_match(same_file_other_line)
+        end
+
+      end
+
+      context 'a wildcard' do
+        let(:wildcard) { Location.new(file) }
+
+        it "matches any location with the same filename" do
+          expect( wildcard ).to be_match(matching)
+        end
+
+        it "is matched by any location of the same file" do
+          expect( matching ).to be_match(wildcard)
+        end
+
+        it "does not match a location in a different file" do
+          expect( wildcard ).not_to be_match(not_matching)
+        end
+      end
+    end
+
+    describe "created from source location" do
+      context "when the location is in the tree below pwd" do
+        it "create a relative path from pwd" do
+          expect( Location.from_source_location(Dir.pwd + "/path/file.rb", 1).file ).to eq "path/file.rb"
+        end
+      end
+
+      context "when the location is in an installed gem" do
+        it "create a relative path from the gem directory" do
+          expect( Location.from_source_location("/path/gems/gem-name/path/file.rb", 1).file ).to eq "gem-name/path/file.rb"
+        end
+      end
+
+      context "when the location is neither below pwd nor in an installed gem" do
+        it "use the absolute path to the file" do
+          expect( Location.from_source_location("/path/file.rb", 1).file ).to eq "/path/file.rb"
+        end
+      end
+    end
+
+    describe "created from file-colon-line" do
+      it "handles also Windows paths" do
+        expect( Location.from_file_colon_line("c:\path\file.rb:123").file ).to eq "c:\path\file.rb"
+      end
+    end
+
+    describe "created of caller" do
+      it "use the location of the caller" do
+        expect( Location.of_caller.to_s ).to be_included_in caller[0]
+      end
+
+      context "when specifying additional caller depth"do
+        it "use the location of the n:th caller" do
+          expect( Location.of_caller(1).to_s ).to be_included_in caller[1]
+        end
+      end
+    end
+  end
+end