cucumber-core 3.0.0 → 3.1.0

data/spec/cucumber/core/ast/outline_step_spec.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/outline_step'
-require 'cucumber/core/ast/examples_table'
-require 'cucumber/core/ast/data_table'
-require 'cucumber/core/ast/doc_string'
-require 'cucumber/core/ast/empty_multiline_argument'
-
-module Cucumber
-  module Core
-    module Ast
-      describe OutlineStep do
-        let(:outline_step) { OutlineStep.new(language, location, comments, keyword, text, multiline_arg) }
-        let(:language) { double }
-        let(:location) { double }
-        let(:comments)  { double }
-        let(:keyword)  { double }
-        let(:text)     { 'anything' }
-        let(:multiline_arg) { EmptyMultilineArgument.new }
-
-        describe 'location' do
-          it "has a location" do
-            expect( outline_step ).to respond_to(:location)
-          end
-
-          it 'knows the file and line' do
-            allow( location ).to receive(:to_s) { 'file_name:8' }
-            expect( outline_step.file_colon_line ).to eq 'file_name:8'
-          end
-        end
-
-        describe "to_s" do
-          it "returns the text of the step" do
-            expect(outline_step.to_s).to eq 'anything'
-          end
-        end
-
-        describe 'comments' do
-          it "has comments" do
-            expect( outline_step ).to respond_to(:comments)
-          end
-        end
-
-        describe "converting to a Step" do
-          context "a single argument in the name" do
-            let(:text) { 'a <color> cucumber' }
-
-            it "replaces the argument" do
-              row = ExamplesTable::Row.new({'color' => 'green'}, 1, location, language, comments)
-              expect( outline_step.to_step(row).text ).to eq 'a green cucumber'
-            end
-
-          end
-
-          context "when the step has a DataTable" do
-            let(:outline_step) { OutlineStep.new(language, location, comments, keyword, text, table) }
-            let(:text)  { "anything" }
-            let(:table) { DataTable.new([['x', 'y'],['a', 'a <arg>']], Location.new('foo.feature', 23)) }
-
-            it "replaces the arguments in the DataTable" do
-              visitor = double
-              allow( visitor ).to receive(:step).and_yield(visitor)
-              expect( visitor ).to receive(:data_table) do |data_table|
-                expect( data_table.raw ).to eq [['x', 'y'], ['a', 'a replacement']]
-              end
-              row = ExamplesTable::Row.new({'arg' => 'replacement'}, 1, location, language, comments)
-              step = outline_step.to_step(row)
-              step.describe_to(visitor)
-            end
-          end
-
-          context "when the step has a DocString" do
-            let(:location) { double }
-            let(:outline_step) { OutlineStep.new(language, location, comments, keyword, text, doc_string) }
-            let(:doc_string) { DocString.new('a <arg> that needs replacing', '', location) }
-            let(:text) { 'anything' }
-
-            it "replaces the arguments in the DocString" do
-              visitor = double
-              allow( visitor ).to receive(:step).and_yield(visitor)
-              expect( visitor ).to receive(:doc_string) do |doc_string|
-                expect( doc_string.content ).to eq "a replacement that needs replacing"
-              end
-              row = ExamplesTable::Row.new({'arg' => 'replacement'}, 1, location, language, comments)
-              step = outline_step.to_step(row)
-              step.describe_to(visitor)
-            end
-          end
-        end
-      end
-    end
-  end
-end
-

data/spec/cucumber/core/ast/step_spec.rb

@@ -1,174 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/ast/step'
-require 'cucumber/core/ast/outline_step'
-require 'cucumber/core/ast/empty_multiline_argument'
-require 'gherkin/dialect'
-
-module Cucumber
-  module Core
-    module Ast
-      describe Step do
-        let(:step) do
-          text = "a passing step"
-          keyword = "Given"
-          language, location, comments = *double
-          multiline_arg = EmptyMultilineArgument.new
-          Step.new(language, location, comments, keyword, text, multiline_arg)
-        end
-
-        describe "to_s" do
-          it("returns the text of the step") do
-            expect(step.to_s).to eq("a passing step")
-          end
-        end
-
-        describe "describing itself" do
-          let(:visitor) { double }
-
-          it "describes itself as a step" do
-            expect( visitor ).to receive(:step).with(step)
-            step.describe_to(visitor)
-          end
-
-          context "with no multiline argument" do
-            it "does not try to describe any children" do
-              allow( visitor ).to receive(:step).with(step).and_yield(visitor)
-              step.describe_to(visitor)
-            end
-          end
-
-          context "with a multiline argument" do
-            let(:step) { Step.new(double, double, double, double, double, multiline_arg) }
-            let(:multiline_arg) { double }
-
-            it "tells its multiline argument to describe itself" do
-              allow( visitor ).to receive(:step).with(step).and_yield(visitor)
-              expect( multiline_arg ).to receive(:describe_to).with(visitor)
-              step.describe_to(visitor)
-            end
-          end
-
-        end
-
-        describe 'comments' do
-          it "has comments" do
-            expect( step ).to respond_to(:comments)
-          end
-        end
-
-        describe "backtrace line" do
-          let(:step) { Step.new(double, "path/file.feature:10", double, "Given ", "this step passes", double) }
-
-          it "knows how to form the backtrace line" do
-            expect( step.backtrace_line ).to eq("path/file.feature:10:in `Given this step passes'")
-          end
-
-        end
-
-        describe "actual keyword" do
-          let(:language) { ::Gherkin::Dialect.for('en') }
-
-          context "for keywords 'given', 'when' and 'then'" do
-            let(:given_step) { Step.new(language, double, double, "Given ", double, double) }
-            let(:when_step) { Step.new(language, double, double, "When ", double, double) }
-            let(:then_step) { Step.new(language, double, double, "Then ", double, double) }
-
-            it "returns the keyword itself" do
-              expect( given_step.actual_keyword(nil) ).to eq("Given ")
-              expect( when_step.actual_keyword(nil) ).to eq("When ")
-              expect( then_step.actual_keyword(nil) ).to eq("Then ")
-            end
-          end
-
-          context "for keyword 'and', 'but', and '*'" do
-            let(:and_step) { Step.new(language, double, double, "And ", double, double) }
-            let(:but_step) { Step.new(language, double, double, "But ", double, double) }
-            let(:asterisk_step) { Step.new(language, double, double, "* ", double, double) }
-
-            context "when the previous step keyword exist" do
-              it "returns the previous step keyword" do
-                expect( and_step.actual_keyword("Then ") ).to eq("Then ")
-                expect( but_step.actual_keyword("Then ") ).to eq("Then ")
-                expect( asterisk_step.actual_keyword("Then ") ).to eq("Then ")
-              end
-            end
-
-            context "when the previous step keyword does not exist" do
-              it "returns the 'given' keyword" do
-                expect( and_step.actual_keyword(nil) ).to eq("Given ")
-                expect( but_step.actual_keyword(nil) ).to eq("Given ")
-                expect( asterisk_step.actual_keyword(nil) ).to eq("Given ")
-              end
-            end
-
-          end
-
-          context "for i18n languages" do
-            let(:language) { ::Gherkin::Dialect.for('en-lol') }
-            let(:and_step) { Step.new(language, double, double, "AN ", double, double) }
-
-            it "returns the keyword in the correct language" do
-              expect( and_step.actual_keyword(nil) ).to eq("I CAN HAZ ")
-            end
-          end
-        end
-      end
-
-      describe ExpandedOutlineStep do
-        let(:outline_step) { double }
-        let(:step) do
-          language, location, keyword, text = *double
-          multiline_arg = EmptyMultilineArgument.new
-          comments = []
-          ExpandedOutlineStep.new(outline_step, language, location, comments, keyword, text, multiline_arg)
-        end
-
-        describe "describing itself" do
-          let(:visitor) { double }
-
-          it "describes itself as a step" do
-            expect( visitor ).to receive(:step).with(step)
-            step.describe_to(visitor)
-          end
-
-          context "with no multiline argument" do
-            it "does not try to describe any children" do
-              allow( visitor ).to receive(:step).with(step).and_yield(visitor)
-              step.describe_to(visitor)
-            end
-          end
-
-          context "with a multiline argument" do
-            let(:step) { Step.new(double, double, double, double, double, multiline_arg) }
-            let(:multiline_arg) { double }
-
-            it "tells its multiline argument to describe itself" do
-              allow( visitor ).to receive(:step).with(step).and_yield(visitor)
-              expect( multiline_arg ).to receive(:describe_to).with(visitor)
-              step.describe_to(visitor)
-            end
-          end
-
-        end
-
-        describe 'comments' do
-          it "has comments" do
-            expect( step ).to respond_to(:comments)
-          end
-        end
-
-        describe "backtrace line" do
-          let(:outline_step) { OutlineStep.new(double, "path/file.feature:5", double, "Given ", "this step <state>", double) }
-          let(:step) { ExpandedOutlineStep.new(outline_step, double, "path/file.feature:10", double, "Given ", "this step passes", double) }
-
-          it "includes the outline step in the backtrace line" do
-            expect( step.backtrace_line ).to eq("path/file.feature:10:in `Given this step passes'\n" +
-                                                "path/file.feature:5:in `Given this step <state>'")
-          end
-
-        end
-      end
-    end
-  end
-end
-

data/spec/cucumber/core/compiler_spec.rb

@@ -1,267 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core'
-require 'cucumber/core/compiler'
-require 'cucumber/core/gherkin/writer'
-
-module Cucumber::Core
-  describe Compiler do
-    include Gherkin::Writer
-    include Cucumber::Core
-
-    def self.stubs(*names)
-      names.each do |name|
-        let(name) { double(name.to_s) }
-      end
-    end
-
-    it "compiles a feature with a single scenario" do
-      gherkin_documents = [
-        gherkin do
-          feature do
-            scenario do
-              step 'passing'
-            end
-          end
-        end
-      ]
-      compile(gherkin_documents) do |visitor|
-        expect( visitor ).to receive(:test_case).once.ordered.and_yield(visitor)
-        expect( visitor ).to receive(:test_step).once.ordered
-        expect( visitor ).to receive(:done).once.ordered
-      end
-    end
-
-    it "compiles a feature with a background" do
-      gherkin_documents = [
-        gherkin do
-          feature do
-            background do
-              step 'passing'
-            end
-
-            scenario do
-              step 'passing'
-            end
-          end
-        end
-      ]
-      compile(gherkin_documents) do |visitor|
-        expect( visitor ).to receive(:test_case).once.ordered.and_yield(visitor)
-        expect( visitor ).to receive(:test_step).exactly(2).times.ordered
-        expect( visitor ).to receive(:done).once.ordered
-      end
-    end
-
-    it "compiles multiple features" do
-      gherkin_documents = [
-        gherkin do
-          feature do
-            background do
-              step 'passing'
-            end
-            scenario do
-              step 'passing'
-            end
-          end
-        end,
-        gherkin do
-          feature do
-            background do
-              step 'passing'
-            end
-            scenario do
-              step 'passing'
-            end
-          end
-        end
-      ]
-      compile(gherkin_documents) do |visitor|
-        expect( visitor ).to receive(:test_case).once.ordered
-        expect( visitor ).to receive(:test_step).twice.ordered
-        expect( visitor ).to receive(:test_case).once.ordered
-        expect( visitor ).to receive(:test_step).twice.ordered
-        expect( visitor ).to receive(:done).once
-      end
-    end
-
-    context "compiling scenario outlines" do
-      it "compiles a scenario outline to test cases" do
-        gherkin_documents = [
-          gherkin do
-            feature do
-              background do
-                step 'passing'
-              end
-
-              scenario_outline do
-                step 'passing <arg>'
-                step 'passing'
-
-                examples 'examples 1' do
-                  row 'arg'
-                  row '1'
-                  row '2'
-                end
-
-                examples 'examples 2' do
-                  row 'arg'
-                  row 'a'
-                end
-              end
-            end
-          end
-        ]
-        compile(gherkin_documents) do |visitor|
-          expect( visitor ).to receive(:test_case).exactly(3).times.and_yield(visitor)
-          expect( visitor ).to receive(:test_step).exactly(9).times
-          expect( visitor ).to receive(:done).once
-        end
-      end
-
-      it 'replaces arguments correctly when generating test steps' do
-        gherkin_documents = [
-          gherkin do
-            feature do
-              scenario_outline do
-                step 'passing <arg1> with <arg2>'
-                step 'as well as <arg3>'
-
-                examples do
-                  row 'arg1', 'arg2', 'arg3'
-                  row '1',    '2',    '3'
-                end
-              end
-            end
-          end
-        ]
-
-        compile(gherkin_documents) do |visitor|
-          expect( visitor ).to receive(:test_step) do |test_step|
-            visit_source(test_step) do |source_visitor|
-              expect( source_visitor ).to receive(:step) do |step|
-                expect(step.text).to eq 'passing 1 with 2'
-              end
-            end
-          end.once.ordered
-
-          expect( visitor ).to receive(:test_step) do |test_step|
-            visit_source(test_step) do |source_visitor|
-              expect( source_visitor ).to receive(:step) do |step|
-                expect(step.text).to eq 'as well as 3'
-              end
-            end
-          end.once.ordered
-
-          expect( visitor ).to receive(:done).once.ordered
-        end
-      end
-    end
-
-    context 'empty scenarios' do
-      it 'does not create test cases for them' do
-        gherkin_documents = [
-          gherkin do
-            feature do
-              scenario do
-              end
-            end
-          end
-        ]
-        compile(gherkin_documents) do |visitor|
-          expect( visitor ).to receive(:test_case).never
-          expect( visitor ).to receive(:done).once.ordered
-        end
-      end
-    end
-
-    describe Compiler::FeatureCompiler do
-      let(:receiver) { double('receiver') }
-      let(:compiler) { Compiler::FeatureCompiler.new(receiver) }
-
-      context "a scenario with a background" do
-        stubs(:feature,
-                :background,
-                  :background_step,
-                :scenario,
-                  :scenario_step)
-
-        it "sets the source correctly on the test steps" do
-          expect( receiver ).to receive(:on_background_step).with(
-            [feature, background, background_step]
-          )
-          expect( receiver ).to receive(:on_step).with(
-            [feature, scenario, scenario_step]
-          )
-          expect( receiver ).to receive(:on_test_case).with(
-            [feature, scenario]
-          )
-          compiler.feature(feature) do |f|
-            f.background(background) do |b|
-              b.step background_step
-            end
-            f.scenario(scenario) do |s|
-              s.step scenario_step
-            end
-          end
-        end
-      end
-
-      context "a scenario outline" do
-        stubs(:feature,
-                :background,
-                  :background_step,
-                :scenario_outline,
-                  :outline_step,
-                  :examples_table_1,
-                    :examples_table_1_row_1,
-                      :outline_ast_step,
-                  :examples_table_2,
-                    :examples_table_2_row_1,
-             )
-
-        it "sets the source correctly on the test steps" do
-          allow( outline_step ).to receive(:to_step) { outline_ast_step }
-          expect( receiver ).to receive(:on_step).with(
-            [feature, scenario_outline, examples_table_1, examples_table_1_row_1, outline_ast_step]
-          ).ordered
-          expect( receiver ).to receive(:on_test_case).with(
-            [feature, scenario_outline, examples_table_1, examples_table_1_row_1]
-          ).ordered
-          expect( receiver ).to receive(:on_step).with(
-            [feature, scenario_outline, examples_table_2, examples_table_2_row_1, outline_ast_step]
-          ).ordered
-          expect( receiver ).to receive(:on_test_case).with(
-            [feature, scenario_outline, examples_table_2, examples_table_2_row_1]
-          ).ordered
-          compiler.feature(feature) do |f|
-            f.scenario_outline(scenario_outline) do |o|
-              o.outline_step outline_step
-              o.examples_table(examples_table_1) do |t|
-                t.examples_table_row(examples_table_1_row_1)
-              end
-              o.examples_table(examples_table_2) do |t|
-                t.examples_table_row(examples_table_2_row_1)
-              end
-            end
-          end
-        end
-      end
-    end
-
-    def visit_source(node)
-      visitor = double.as_null_object
-      yield visitor
-      node.describe_source_to(visitor)
-    end
-
-    def compile(gherkin_documents)
-      visitor = double
-      allow( visitor ).to receive(:test_suite).and_yield(visitor)
-      allow( visitor ).to receive(:test_case).and_yield(visitor)
-      yield visitor
-      super(gherkin_documents, visitor)
-    end
-
-  end
-end
-