cucumber-core 11.0.0 → 11.1.0

data/spec/cucumber/core/filter_spec.rb

@@ -1,101 +0,0 @@
-# frozen_string_literal: true
-require 'cucumber/core/gherkin/writer'
-require 'cucumber/core'
-require 'cucumber/core/filter'
-
-module Cucumber::Core
-  describe Filter do
-    include Cucumber::Core::Gherkin::Writer
-    include Cucumber::Core
-
-    describe ".new" do
-      let(:receiver) { double.as_null_object }
-
-      let(:doc) {
-        gherkin do
-          feature do
-            scenario 'x' do
-              step 'a step'
-            end
-
-            scenario 'y' do
-              step 'a step'
-            end
-          end
-        end
-      }
-
-      it "creates a filter class that can pass-through by default" do
-        my_filter_class = Filter.new
-        my_filter = my_filter_class.new
-        expect(receiver).to receive(:test_case) { |test_case|
-          expect(test_case.test_steps.length).to eq 1
-          expect(test_case.test_steps.first.text).to eq 'a step'
-        }.exactly(2).times
-        compile [doc], receiver, [my_filter]
-      end
-
-      context "customizing by subclassing" do
-
-        # Each filter imlicitly gets a :receiver attribute
-        # that you need to call with the new test case
-        # once you've received yours and modified it.
-        class BasicBlankingFilter < Filter.new
-          def test_case(test_case)
-            test_case.with_steps([]).describe_to(receiver)
-          end
-        end
-
-        # You can pass the names of attributes when building a
-        # filter, allowing you to have custom attributes.
-        class NamedBlankingFilter < Filter.new(:name_pattern)
-          def test_case(test_case)
-            if test_case.name =~ name_pattern
-              test_case.with_steps([]).describe_to(receiver)
-            else
-              test_case.describe_to(receiver) # or just call `super`
-            end
-            self
-          end
-        end
-
-        it "can override methods from the base class" do
-          expect(receiver).to receive(:test_case) { |test_case|
-            expect(test_case.test_steps.length).to eq 0
-          }.exactly(2).times
-          run BasicBlankingFilter.new
-        end
-
-        it "can take arguments" do
-          expect(receiver).to receive(:test_case) { |test_case|
-            expect(test_case.test_steps.length).to eq 0
-          }.once.ordered
-          expect(receiver).to receive(:test_case) { |test_case|
-            expect(test_case.test_steps.length).to eq 1
-          }.once.ordered
-          run NamedBlankingFilter.new(/x/)
-        end
-
-      end
-
-      context "customizing by using a block" do
-        BlockBlankingFilter = Filter.new do
-          def test_case(test_case)
-            test_case.with_steps([]).describe_to(receiver)
-          end
-        end
-
-        it "allows methods to be overridden" do
-          expect(receiver).to receive(:test_case) { |test_case|
-            expect(test_case.test_steps.length).to eq 0
-          }.exactly(2).times
-          run BlockBlankingFilter.new
-        end
-      end
-
-      def run(filter)
-        compile [doc], receiver, [filter]
-      end
-    end
-  end
-end

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

@@ -1,162 +0,0 @@
-# -*- encoding: utf-8 -*-
-# frozen_string_literal: true
-require 'cucumber/core/gherkin/parser'
-require 'cucumber/core/gherkin/writer'
-
-module Cucumber
-  module Core
-    module Gherkin
-      describe Parser do
-        let(:receiver)  { double }
-        let(:event_bus) { double }
-        let(:gherkin_query) { double }
-        let(:parser)    { Parser.new(receiver, event_bus, gherkin_query) }
-        let(:visitor)   { double }
-
-        before do
-          allow( event_bus ).to receive(:gherkin_source_parsed)
-          allow( event_bus).to receive(:envelope)
-          allow( gherkin_query ).to receive(:update)
-        end
-
-        def parse
-          parser.document(source)
-        end
-
-        context "for invalid gherkin" do
-          let(:source) { Gherkin::Document.new(path, "\nnot gherkin\n\nFeature: \n") }
-          let(:path)   { 'path_to/the.feature' }
-
-          it "raises an error" do
-            expect { parse }.to raise_error(ParseError) do |error|
-              expect( error.message ).to match(/not gherkin/)
-              expect( error.message ).to match(/#{path}/)
-            end
-          end
-        end
-
-        context "for valid gherkin" do
-          let(:source) { Gherkin::Document.new(path, 'Feature:') }
-          let(:path)   { 'path_to/the.feature' }
-
-          it "issues a gherkin_source_parsed event" do
-            expect( event_bus ).to receive(:gherkin_source_parsed)
-            parse
-          end
-
-          it "emits an 'envelope' event for every message produced by Gherkin" do
-            # Only one message emited, there's no pickles generated
-            expect( event_bus ).to receive(:envelope).once
-            parse
-          end
-        end
-
-        context "for empty files" do
-          let(:source) { Gherkin::Document.new(path, '') }
-          let(:path)   { 'path_to/the.feature' }
-
-          it "passes on no pickles" do
-            expect( receiver ).not_to receive(:pickle)
-            parse
-          end
-        end
-
-        include Writer
-        def self.source(&block)
-          let(:source) { gherkin(&block) }
-        end
-
-        RSpec::Matchers.define :pickle_with_language do |language|
-          match { |actual| actual.language == language }
-        end
-
-        context "when the Gherkin has a language header" do
-          source do
-            feature(language: 'ja', keyword: '機能') do
-              scenario(keyword: 'シナリオ')
-            end
-          end
-
-          it "the pickles have the correct language" do
-            expect( receiver ).to receive(:pickle).with(pickle_with_language('ja'))
-            parse
-          end
-        end
-
-        context "when the Gherkin produces one pickle" do
-          source do
-            feature do
-              scenario do
-                step 'text'
-              end
-            end
-          end
-
-          it "passes on the pickle" do
-            expect( receiver ).to receive(:pickle)
-            parse
-          end
-
-          it "emits an 'envelope' event containing the pickle" do
-            allow( receiver ).to receive(:pickle)
-            # Once for the gherkin document, once with the pickle
-            expect( event_bus ).to receive(:envelope).twice
-            parse
-          end
-        end
-
-        context "when scenario is inside a rule" do
-          source do
-            feature do
-              rule do
-                scenario name: "My scenario"
-              end
-            end
-          end
-
-          it "passes on the pickle" do
-            expect( receiver ).to receive(:pickle)
-            parse
-          end
-        end
-
-        context "when example is inside a rule" do
-          source do
-            feature do
-              rule do
-                example name: "My example"
-              end
-            end
-          end
-
-          it "passes on the pickle" do
-            expect( receiver ).to receive(:pickle)
-            parse
-          end
-        end
-
-        context "when there are multiple rules and scenarios or examples" do
-          source do
-            feature do
-              rule description: "First rule" do
-                scenario name: "Do not talk about the fight club" do
-                  step 'text'
-                end
-              end
-              rule description: "Second rule" do
-                example name: "Do not talk about the fight club" do
-                  step 'text'
-                end
-              end
-            end
-          end
-
-          it "passes on the pickles" do
-            expect( receiver ).to receive(:pickle).twice
-            parse
-          end
-        end
-      end
-    end
-  end
-end

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