cucumber-core 4.0.0 → 5.0.0

data/spec/cucumber/core/event_spec.rb

@@ -0,0 +1,40 @@
+require 'cucumber/core/event'
+
+module Cucumber
+  module Core
+    describe Event do
+
+      describe ".new" do
+        it "generates new types of events" do
+          my_event_type = Event.new
+          my_event = my_event_type.new
+          expect(my_event).to be_kind_of(Core::Event)
+        end
+
+        it "generates events with attributes" do
+          my_event_type = Event.new(:foo, :bar)
+          my_event = my_event_type.new(1,2)
+          expect(my_event.attributes).to eq [1, 2]
+          expect(my_event.foo).to eq 1
+          expect(my_event.bar).to eq 2
+        end
+      end
+
+      describe "a generated event" do
+        class MyEventType < Event.new(:foo, :bar)
+        end
+
+        it "can be converted to a hash" do
+          my_event = MyEventType.new(1,2)
+          expect(my_event.to_h).to eq foo: 1, bar: 2
+        end
+
+        it "has an event_id" do
+          expect(MyEventType.event_id).to eq :my_event_type
+          expect(MyEventType.new(1,2).event_id).to eq :my_event_type
+        end
+      end
+    end
+
+  end
+end

data/spec/cucumber/core/filter_spec.rb

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

@@ -0,0 +1,95 @@
+# -*- 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(:parser)    { Parser.new(receiver, event_bus) }
+        let(:visitor)   { double }
+
+        before do
+          allow( event_bus ).to receive(:gherkin_source_parsed)
+        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
+        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
+        end
+
+      end
+    end
+  end
+end

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

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