cucumber-core 10.1.1 → 11.1.0

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

@@ -1,332 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/gherkin/writer'
-require 'unindent'
-
-module Cucumber::Core::Gherkin
-  describe Writer do
-    include Writer
-
-    context 'specifying uri' do
-      it 'generates a uri by default' do
-        source = gherkin { feature }
-        expect( source.uri ).to eq 'features/test.feature'
-      end
-
-      it 'allows you to specify a URI' do
-        source = gherkin('features/path/to/my.feature') { feature }
-        expect( source.uri ).to eq 'features/path/to/my.feature'
-      end
-    end
-
-    context 'a feature' do
-
-      it 'generates the feature statement' do
-        source = gherkin { feature }
-        expect( source ).to eq "Feature:\n"
-      end
-
-      context 'when a name is provided' do
-        it 'includes the name in the feature statement' do
-          source = gherkin do
-            feature "A Feature\n"
-          end
-          expect( source ).to eq "Feature: A Feature\n"
-        end
-      end
-
-      context 'when a description is provided' do
-        it 'includes the description in the feature statement' do
-          source = gherkin do
-            feature "A Feature", description: <<-END
-              This is the description
-              which can span
-              multiple lines.
-              END
-          end
-          expected = <<-END
-          Feature: A Feature
-            This is the description
-            which can span
-            multiple lines.
-          END
-
-          expect( source ).to eq expected.unindent
-        end
-      end
-
-      context 'when a keyword is provided' do
-        it 'uses the supplied keyword' do
-          source = gherkin do
-            feature "A Feature", keyword: "Business Need"
-          end
-          expect( source ).to eq "Business Need: A Feature\n"
-        end
-      end
-
-      context 'when a language is supplied' do
-        it 'inserts a language statement' do
-          source = gherkin do
-            feature language: 'ru'
-          end
-
-          expect( source ).to eq "# language: ru\nFeature:\n"
-        end
-      end
-
-      context 'when a comment is supplied' do
-        it 'inserts a comment' do
-          source = gherkin do
-            comment 'wow'
-            comment 'great'
-            feature
-          end
-
-          expect( source.to_s ).to eq "# wow\n# great\nFeature:\n"
-        end
-      end
-
-      context 'with a scenario' do
-        it 'includes the scenario statement' do
-          source = gherkin do
-            feature "A Feature" do
-              scenario
-            end
-          end
-
-          expect( source.to_s ).to match(/Scenario:/)
-        end
-
-        context 'when a comment is provided' do
-          it 'includes the comment in the scenario statement' do
-            source = gherkin do
-              feature do
-                comment 'wow'
-                scenario
-              end
-            end
-            expect( source.to_s ).to eq <<-END.unindent
-            Feature:
-
-              # wow
-              Scenario:
-            END
-          end
-        end
-
-        context 'when a description is provided' do
-          it 'includes the description in the scenario statement' do
-            source = gherkin do
-              feature do
-                scenario description: <<-END
-                  This is the description
-                  which can span
-                  multiple lines.
-                  END
-              end
-            end
-
-            expect( source ).to eq <<-END.unindent
-            Feature:
-
-              Scenario:
-                This is the description
-                which can span
-                multiple lines.
-            END
-          end
-        end
-
-        context 'with a step' do
-          it 'includes the step statement' do
-            source = gherkin do
-              feature "A Feature" do
-                scenario do
-                  step 'passing'
-                end
-              end
-            end
-
-            expect( source.to_s ).to match(/Given passing\Z/m)
-          end
-
-          context 'when a docstring is provided' do
-            it 'includes the content type when provided' do
-              source = gherkin do
-                feature do
-                  scenario do
-                    step 'failing' do
-                      doc_string 'some text', 'text/plain'
-                    end
-                  end
-                end
-
-              end
-
-              expect( source ).to eq <<-END.unindent
-              Feature:
-
-                Scenario:
-                  Given failing
-                    """text/plain
-                    some text
-                    """
-              END
-            end
-          end
-        end
-      end
-
-      context 'with a background' do
-        it 'can have a description' do
-          source = gherkin do
-            feature do
-              background description: "One line,\nand two.."
-            end
-          end
-
-          expect( source ).to eq <<-END.unindent
-          Feature:
-
-            Background:
-              One line,
-              and two..
-          END
-        end
-      end
-
-      context 'with a scenario outline' do
-        it 'can have a description' do
-          source = gherkin do
-            feature do
-              scenario_outline description: "Doesn't need to be multi-line."
-            end
-          end
-
-          expect( source ).to eq <<-END.unindent
-          Feature:
-
-            Scenario Outline:
-              Doesn't need to be multi-line.
-          END
-        end
-
-        context 'and examples table' do
-          it 'can have a description' do
-            source = gherkin do
-              feature do
-                scenario_outline do
-                  examples description: "Doesn't need to be multi-line." do
-
-                  end
-                end
-              end
-            end
-
-            expect( source ).to eq <<-END.unindent
-            Feature:
-
-              Scenario Outline:
-
-                Examples:
-                  Doesn't need to be multi-line.
-            END
-          end
-        end
-      end
-    end
-
-    it 'generates a complex feature' do
-      source = gherkin do
-        comment 'wow'
-        feature 'Fully featured', language: 'en', tags: '@always' do
-          comment 'cool'
-          background do
-            step 'passing'
-          end
-
-          scenario do
-            step 'passing'
-          end
-
-          comment 'here'
-          scenario 'with doc string', tags: '@first @second' do
-            comment 'and here'
-            step 'passing'
-            step 'failing', keyword: 'When' do
-              doc_string <<-END
-              I wish I was a little bit taller.
-              I wish I was a baller.
-              END
-            end
-          end
-
-          scenario 'with a table...' do
-            step 'passes:' do
-              table do
-                row 'name',   'age', 'location'
-                row 'Janine', '43',  'Antarctica'
-              end
-            end
-          end
-
-          comment 'yay'
-          scenario_outline 'eating' do
-            step 'there are <start> cucumbers'
-            step 'I eat <eat> cucumbers', keyword: 'When'
-            step 'I should have <left> cucumbers', keyword: 'Then'
-
-            comment 'hmmm'
-            examples do
-              row 'start', 'eat', 'left'
-              row '12',    '5',   '7'
-              row '20',    '5',   '15'
-            end
-          end
-        end
-      end
-
-      expect( source.to_s ).to eq <<-END.unindent
-      # language: en
-      # wow
-      @always
-      Feature: Fully featured
-
-        # cool
-        Background:
-          Given passing
-
-        Scenario:
-          Given passing
-
-        # here
-        @first @second
-        Scenario: with doc string
-          # and here
-          Given passing
-          When failing
-            """
-            I wish I was a little bit taller.
-            I wish I was a baller.
-            """
-
-        Scenario: with a table...
-          Given passes:
-            | name   | age | location   |
-            | Janine | 43  | Antarctica |
-
-        # yay
-        Scenario Outline: eating
-          Given there are <start> cucumbers
-          When I eat <eat> cucumbers
-          Then I should have <left> cucumbers
-
-          # hmmm
-          Examples:
-            | start | eat | left |
-            | 12    | 5   | 7    |
-            | 20    | 5   | 15   |
-      END
-
-    end
-  end
-end

data/spec/cucumber/core/report/summary_spec.rb

@@ -1,178 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'cucumber/core/event_bus'
-require 'cucumber/core/events'
-require 'cucumber/core/report/summary'
-require 'cucumber/core/test/result'
-
-module Cucumber::Core::Report
-  describe Summary do
-    let(:event_bus) { ::Cucumber::Core::EventBus.new(registry) }
-    let(:registry) { ::Cucumber::Core::Events.registry }
-    let(:passed_result) { ::Cucumber::Core::Test::Result::Passed.new(duration) }
-    let(:failed_result) { ::Cucumber::Core::Test::Result::Failed.new(duration, exception) }
-    let(:pending_result) { ::Cucumber::Core::Test::Result::Pending.new(duration) }
-    let(:skipped_result) { ::Cucumber::Core::Test::Result::Skipped.new(duration) }
-    let(:undefined_result) { ::Cucumber::Core::Test::Result::Undefined.new(duration) }
-    let(:duration) { double }
-    let(:exception) { double }
-
-    before(:each) { @summary = Summary.new(event_bus) }
-
-    context "test case summary" do
-      let(:test_case) { double }
-
-      it "counts passed test cases" do
-        event_bus.send(:test_case_finished, test_case, passed_result)
-
-        expect( @summary.test_cases.total(:passed) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-
-      it "counts failed test cases" do
-        event_bus.send(:test_case_finished, test_case, failed_result)
-
-        expect( @summary.test_cases.total(:failed) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-
-      it "counts pending test cases" do
-        event_bus.send(:test_case_finished, test_case, pending_result)
-
-        expect( @summary.test_cases.total(:pending) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-
-      it "counts skipped test cases" do
-        event_bus.send(:test_case_finished, test_case, skipped_result)
-
-        expect( @summary.test_cases.total(:skipped) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-
-      it "counts undefined test cases" do
-        event_bus.send(:test_case_finished, test_case, undefined_result)
-
-        expect( @summary.test_cases.total(:undefined) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-
-      it "handles flaky test cases" do
-        allow(test_case).to receive(:==).and_return(false, true)
-        event_bus.send(:test_case_finished, test_case, failed_result)
-        event_bus.send(:test_case_finished, test_case, passed_result)
-
-        expect( @summary.test_cases.total(:failed) ).to eq(0)
-        expect( @summary.test_cases.total(:flaky) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-
-      it "handless flaky with following skip test cases" do
-        allow(test_case).to receive(:==).and_return(false, true)
-        event_bus.send(:test_case_finished, test_case, failed_result)
-        event_bus.send(:test_case_finished, test_case, skipped_result)
-
-        expect( @summary.test_cases.total(:failed) ).to eq(0)
-        expect( @summary.test_cases.total(:skipped) ).to eq(0)
-        expect( @summary.test_cases.total(:flaky) ).to eq(1)
-        expect( @summary.test_cases.total ).to eq(1)
-      end
-    end
-
-    context "test step summary" do
-      context "with test steps from gherkin steps" do
-        let(:test_step) { double }
-
-        before(:each) do
-          expect( test_step ).to receive(:hook?).and_return(false)
-        end
-
-        it "counts passed test steps" do
-          event_bus.send(:test_step_finished, test_step, passed_result)
-
-          expect( @summary.test_steps.total(:passed) ).to eq(1)
-          expect( @summary.test_steps.total ).to eq(1)
-        end
-
-        it "counts failed test cases" do
-          event_bus.send(:test_step_finished, test_step, failed_result)
-
-          expect( @summary.test_steps.total(:failed) ).to eq(1)
-          expect( @summary.test_steps.total ).to eq(1)
-        end
-
-        it "counts pending test cases" do
-          event_bus.send(:test_step_finished, test_step, pending_result)
-
-          expect( @summary.test_steps.total(:pending) ).to eq(1)
-          expect( @summary.test_steps.total ).to eq(1)
-        end
-
-        it "counts skipped test cases" do
-          event_bus.send(:test_step_finished, test_step, skipped_result)
-
-          expect( @summary.test_steps.total(:skipped) ).to eq(1)
-          expect( @summary.test_steps.total ).to eq(1)
-        end
-
-        it "counts undefined test cases" do
-          event_bus.send(:test_step_finished, test_step, undefined_result)
-
-          expect( @summary.test_steps.total(:undefined) ).to eq(1)
-          expect( @summary.test_steps.total ).to eq(1)
-        end
-      end
-
-      context "with test steps not from gherkin steps" do
-        let(:test_step) { double }
-
-        before(:each) do
-          expect( test_step ).to receive(:hook?).and_return(true)
-        end
-
-        it "ignores test steps not defined by gherkin steps" do
-          event_bus.send(:test_step_finished, test_step, passed_result)
-
-          expect( @summary.test_steps.total ).to eq(0)
-        end
-      end
-    end
-
-    context "ok? result" do
-      let(:test_case) { double }
-
-      it "passed test case is ok" do
-        event_bus.send(:test_case_finished, test_case, passed_result)
-
-        expect( @summary.ok? ).to eq true
-      end
-
-      it "skipped test case is ok" do
-        event_bus.send(:test_case_finished, test_case, skipped_result)
-
-        expect( @summary.ok? ).to eq true
-      end
-
-      it "failed test case is not ok" do
-        event_bus.send(:test_case_finished, test_case, failed_result)
-
-        expect( @summary.ok? ).to eq false
-      end
-
-      it "pending test case is ok if not strict" do
-        event_bus.send(:test_case_finished, test_case, pending_result)
-
-        expect( @summary.ok? ).to eq true
-        be_strict = ::Cucumber::Core::Test::Result::StrictConfiguration.new([:pending])
-        expect( @summary.ok?(be_strict) ).to eq false
-      end
-
-      it "undefined test case is ok if not strict" do
-        event_bus.send(:test_case_finished, test_case, undefined_result)
-
-        expect( @summary.ok? ).to eq true
-        be_strict = ::Cucumber::Core::Test::Result::StrictConfiguration.new([:undefined])
-        expect( @summary.ok?(be_strict) ).to eq false
-      end
-    end
-  end
-end

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

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/test/action'
-require 'cucumber/core/test/duration_matcher'
-
-module Cucumber
-  module Core
-    module Test
-
-      describe Action do
-
-        context "constructed without a block" do
-          it "raises an error" do
-            expect { Action.new }.to raise_error(ArgumentError)
-          end
-        end
-
-        context "location" do
-
-          context "with location passed to the constructor" do
-            let(:location) { double }
-
-            it "returns the location passed to the constructor" do
-              action = Action.new(location) {}
-              expect( action.location ).to be location
-            end
-          end
-
-          context "without location passed to the constructor" do
-            let(:block) { proc {} }
-
-            it "returns the location of the block passed to the constructor" do
-              action = Action.new(&block)
-              expect( action.location ).to eq Test::Location.new(*block.source_location)
-            end
-          end
-
-        end
-
-        context "executing" do
-          it "executes the block passed to the constructor" do
-            executed = false
-            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
-            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
-            action = Action.new { raise exception }
-            result = action.execute
-            expect( result ).to be_failed
-            expect( result.exception ).to eq exception
-          end
-
-          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")
-            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")
-            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")
-            action = Action.new { raise exception }
-            result = action.execute
-            expect( result ).to be_undefined
-            expect( result.message ).to eq "new step"
-          end
-
-          context "recording the duration" do
-            before do
-              allow( Timer::MonotonicTime ).to receive(:time_in_nanoseconds).and_return(525702744080000, 525702744080001)
-            end
-
-            it "records the nanoseconds duration of the execution on the result" do
-              action = Action.new { }
-              duration = action.execute.duration
-              expect( duration ).to be_duration 1
-            end
-
-            it "records the duration of a failed execution" do
-              action = Action.new { raise StandardError }
-              duration = action.execute.duration
-              expect( duration ).to be_duration 1
-            end
-          end
-
-        end
-
-        context "skipping" do
-          it "does not execute the block" do
-            executed = false
-            action = Action.new { executed = true }
-            action.skip
-            expect( executed ).to be_falsey
-          end
-
-          it "returns a skipped result" do
-            action = Action.new {}
-            expect( action.skip ).to be_skipped
-          end
-        end
-      end
-
-      describe UndefinedAction do
-        let(:location) { double }
-        let(:action) { UndefinedAction.new(location) }
-        let(:test_step) { double }
-
-        context "location" do
-          it "returns the location passed to the constructor" do
-            expect( action.location ).to be location
-          end
-        end
-
-        context "executing" do
-          it "returns an undefined result" do
-            expect( action.execute ).to be_undefined
-          end
-        end
-
-        context "skipping" do
-          it "returns an undefined result" do
-            expect( action.skip ).to be_undefined
-          end
-        end
-      end
-
-    end
-  end
-end