cucumber-core 4.0.0 → 5.0.0

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

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

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

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

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+# -*- coding: utf-8 -*-
+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(:name) { double }
+        let(:location) { double }
+        let(:tags) { double }
+        let(:language) { double }
+        let(:test_case) { Test::Case.new(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, second_hook = double, 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(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

@@ -0,0 +1,81 @@
+# encoding: utf-8
+# frozen_string_literal: true
+require 'cucumber/core/test/data_table'
+
+module Cucumber
+  module Core
+    module Test
+      describe DataTable do
+        let(:location) { Test::Location.new('foo.feature', 9..12) }
+
+        before do
+          @table = DataTable.new([
+            %w{one four seven},
+            %w{4444 55555 666666}
+          ], location)
+        end
+
+        describe "equality" do
+          it "is equal to another table with the same data" do
+            expect( DataTable.new([[1,2],[3,4]], location) ).to eq DataTable.new([[1,2],[3,4]], location)
+          end
+
+          it "is not equal to another table with different data" do
+            expect( DataTable.new([[1,2],[3,4]], location) ).not_to eq DataTable.new([[1,2]], location)
+          end
+
+          it "is not equal to a non table" do
+            expect( DataTable.new([[1,2],[3,4]], location) ).not_to eq Object.new
+          end
+        end
+
+        describe "#data_table?" do
+          let(:table) { DataTable.new([[1,2],[3,4]], location) }
+
+          it "returns true" do
+            expect(table).to be_data_table
+          end
+        end
+
+        describe "#doc_string" do
+          let(:table) { DataTable.new([[1,2],[3,4]], location) }
+
+          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} ], location) }
+
+          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*}], location)
+          end
+        end
+
+        describe "#transpose" do
+          before(:each) do
+            @table = DataTable.new([
+              %w{one 1111},
+              %w{two 22222}
+            ], location)
+          end
+
+          it "should transpose the table" do
+            transposed = DataTable.new([
+              %w{one two},
+              %w{1111 22222}
+            ], location)
+            expect( @table.transpose ).to eq( transposed )
+          end
+        end
+
+      end
+    end
+  end
+end