cucumber-core 3.0.0 → 3.1.0

data/spec/cucumber/core/event_bus_spec.rb

@@ -1,163 +0,0 @@
-require "cucumber/core/event_bus"
-
-module Cucumber
-  module Core
-    module Events
-
-      class TestEvent < Core::Event.new(:some_attribute)
-      end
-
-      AnotherTestEvent = Core::Event.new
-
-      UnregisteredEvent = Core::Event.new
-    end
-
-    describe EventBus do
-      let(:event_bus) { EventBus.new(registry) }
-      let(:registry) { { test_event: Events::TestEvent, another_test_event: Events::AnotherTestEvent } }
-
-      context "broadcasting events" do
-
-        it "can broadcast by calling a method named after the event ID" do
-          called = false
-          event_bus.on(:test_event) {called = true }
-          event_bus.test_event
-          expect(called).to be true
-        end
-
-        it "can broadcast by calling the `broadcast` method with an instance of the event type" do
-          called = false
-          event_bus.on(:test_event) {called = true }
-          event_bus.broadcast(Events::TestEvent.new(:some_attribute))
-          expect(called).to be true
-        end
-
-        it "calls a subscriber for an event, passing details of the event" do
-          received_payload = nil
-          event_bus.on :test_event do |event|
-            received_payload = event
-          end
-
-          event_bus.test_event :some_attribute
-
-          expect(received_payload.some_attribute).to eq(:some_attribute)
-        end
-
-        it "does not call subscribers for other events" do
-          handler_called = false
-          event_bus.on :test_event do
-            handler_called = true
-          end
-
-          event_bus.another_test_event
-
-          expect(handler_called).to eq(false)
-        end
-
-        it "broadcasts to multiple subscribers" do
-          received_events = []
-          event_bus.on :test_event do
-            received_events << :event
-          end
-          event_bus.on :test_event do
-            received_events << :event
-          end
-
-          event_bus.test_event(:some_attribute)
-
-          expect(received_events.length).to eq 2
-        end
-
-        it "raises an error when given an event to broadcast that it doesn't recognise" do
-          expect { event_bus.some_unknown_event }.to raise_error(NameError)
-        end
-
-        context "#broadcast method" do
-          it "must be passed an instance of a registered event type" do
-            expect { 
-              event_bus.broadcast Events::UnregisteredEvent
-            }.to raise_error(ArgumentError)
-          end
-        end
-
-      end
-
-      context "subscribing to events" do
-        it "allows subscription by symbol (Event ID)" do
-          received_payload = nil
-          event_bus.on(:test_event) do |event|
-            received_payload = event
-          end
-
-          event_bus.test_event :some_attribute
-
-          expect(received_payload.some_attribute).to eq(:some_attribute)
-        end
-
-        it "raises an error if you use an unknown Event ID" do
-          expect { 
-            event_bus.on(:some_unknown_event) { :whatever }
-          }.to raise_error(ArgumentError)
-        end
-
-        it "allows handlers that are objects with a `call` method" do
-          class MyHandler
-            attr_reader :received_payload
-
-            def call(event)
-              @received_payload = event
-            end
-          end
-
-          handler = MyHandler.new
-          event_bus.on(:test_event, handler)
-
-          event_bus.test_event :some_attribute
-
-          expect(handler.received_payload.some_attribute).to eq :some_attribute
-        end
-
-        it "allows handlers that are procs" do
-          class MyProccyHandler
-            attr_reader :received_payload
-
-            def initialize(event_bus)
-              event_bus.on :test_event, &method(:on_test_event)
-            end
-
-            def on_test_event(event)
-              @received_payload = event
-            end
-          end
-
-          handler = MyProccyHandler.new(event_bus)
-
-          event_bus.test_event :some_attribute
-          expect(handler.received_payload.some_attribute).to eq :some_attribute
-        end
-
-        it "sends events that were broadcast before you subscribed" do
-          event_bus.test_event :some_attribute
-          event_bus.another_test_event
-
-          received_payload = nil
-          event_bus.on(:test_event) do |event|
-            received_payload = event
-          end
-
-          expect(received_payload.some_attribute).to eq(:some_attribute)
-        end
-
-      end
-
-      it "will let you inspect the registry" do
-        expect(event_bus.event_types[:test_event]).to eq Events::TestEvent
-      end
-
-      it "won't let you modify the registry" do
-        expect { event_bus.event_types[:foo] = :bar }.to raise_error(RuntimeError)
-      end
-
-    end
-  end
-end

data/spec/cucumber/core/event_spec.rb

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

@@ -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,261 +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(:parser)   { Parser.new(receiver) }
-        let(:visitor)  { double }
-
-        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
-
-        RSpec::Matchers.define :a_null_feature do
-          match do |actual|
-            allow( visitor ).to receive(:feature).and_throw
-
-            actual.describe_to( visitor )
-          end
-        end
-
-        context "for empty files" do
-          let(:source) { Gherkin::Document.new(path, '') }
-          let(:path)   { 'path_to/the.feature' }
-
-          it "creates a NullFeature" do
-            expect( receiver ).to receive(:feature).with(a_null_feature)
-            parse
-          end
-        end
-
-        include Writer
-        def self.source(&block)
-          let(:source) { gherkin(&block) }
-        end
-
-        def feature
-          result = nil
-          allow( receiver ).to receive(:feature) { |feature| result = feature }
-          parse
-          result
-        end
-
-        context "when the Gherkin has a language header" do
-          source do
-            feature(language: 'ja', keyword: '機能')
-          end
-
-          it "sets the language from the Gherkin" do
-            expect( feature.language.iso_code ).to eq 'ja'
-          end
-        end
-
-        context "a Scenario with a DocString" do
-          source do
-            feature do
-              scenario do
-                step do
-                  doc_string("content")
-                end
-              end
-            end
-          end
-
-          it "parses doc strings without error" do
-            allow( visitor ).to receive(:feature).and_yield(visitor)
-            allow( visitor ).to receive(:scenario).and_yield(visitor)
-            allow( visitor ).to receive(:step).and_yield(visitor)
-
-            location = double
-            expected = Ast::DocString.new("content", "", location)
-            expect( visitor ).to receive(:doc_string).with(expected)
-            feature.describe_to(visitor)
-          end
-
-        end
-
-        context "a Scenario with a DataTable" do
-          source do
-            feature do
-              scenario do
-                step do
-                  table do
-                    row "name", "surname"
-                    row "rob",  "westgeest"
-                  end
-                end
-              end
-            end
-          end
-
-          it "parses the DataTable" do
-            visitor = double
-            allow( visitor ).to receive(:feature).and_yield(visitor)
-            allow( visitor ).to receive(:scenario).and_yield(visitor)
-            allow( visitor ).to receive(:step).and_yield(visitor)
-
-            expected = Ast::DataTable.new([['name', 'surname'], ['rob', 'westgeest']], Ast::Location.new('foo.feature', 23))
-            expect( visitor ).to receive(:data_table).with(expected)
-            feature.describe_to(visitor)
-          end
-        end
-
-        context "a feature file with a comments on different levels" do
-          source do
-            comment 'feature comment'
-            feature do
-              comment 'scenario comment'
-              scenario do
-                comment 'step comment'
-                step
-              end
-              comment 'scenario outline comment'
-              scenario_outline do
-                comment 'outline step comment'
-                step
-                comment 'examples comment'
-                examples do
-                  row
-                  row
-                end
-              end
-            end
-          end
-
-          it "the comments are distibuted to down the ast tree from the feature" do
-            visitor = double
-            expect( visitor ).to receive(:feature) do |feature|
-              expect( feature.comments.join ).to eq "# feature comment"
-              visitor
-            end.and_yield(visitor)
-            expect( visitor ).to receive(:scenario) do |scenario|
-              expect( scenario.comments.join ).to eq "  # scenario comment"
-            end.and_yield(visitor)
-            expect( visitor ).to receive(:step) do |step|
-              expect( step.comments.join ).to eq "    # step comment"
-            end.and_yield(visitor)
-            expect( visitor ).to receive(:scenario_outline) do |scenario_outline|
-              expect( scenario_outline.comments.join ).to eq "  # scenario outline comment"
-            end.and_yield(visitor)
-            expect( visitor ).to receive(:outline_step) do |outline_step|
-              expect( outline_step.comments.join ).to eq "    # outline step comment"
-            end.and_yield(visitor)
-            expect( visitor ).to receive(:examples_table) do |examples_table|
-              expect( examples_table.comments.join ).to eq "    # examples comment"
-            end
-            feature.describe_to(visitor)
-          end
-        end
-
-        context "a Scenario Outline" do
-          source do
-            feature do
-              scenario_outline 'outline name' do
-                step 'passing <arg>'
-
-                examples do
-                  row 'arg'
-                  row '1'
-                  row '2'
-                end
-
-                examples do
-                  row 'arg'
-                  row 'a'
-                end
-              end
-            end
-          end
-
-          it "creates a scenario outline node" do
-            allow( visitor ).to receive(:feature).and_yield(visitor)
-            expect( visitor ).to receive(:scenario_outline) do |outline|
-              expect( outline.name ).to eq 'outline name'
-            end
-            feature.describe_to(visitor)
-          end
-
-          it "creates a step node for each step of the scenario outline" do
-            allow( visitor ).to receive(:feature).and_yield(visitor)
-            allow( visitor ).to receive(:scenario_outline).and_yield(visitor)
-            allow( visitor ).to receive(:examples_table)
-            expect( visitor ).to receive(:outline_step) do |step|
-              expect( step.text ).to eq 'passing <arg>'
-            end
-            feature.describe_to(visitor)
-          end
-
-          it "creates an examples table node for each examples table" do
-            allow( visitor ).to receive(:feature).and_yield(visitor)
-            allow( visitor ).to receive(:scenario_outline).and_yield(visitor)
-            allow( visitor ).to receive(:outline_step)
-            expect( visitor ).to receive(:examples_table).exactly(2).times.and_yield(visitor)
-            expect( visitor ).to receive(:examples_table_row) do |row|
-              expect( row.number ).to eq 1
-              expect( row.values ).to eq ['1']
-            end.once.ordered
-            expect( visitor ).to receive(:examples_table_row) do |row|
-              expect( row.number ).to eq 2
-              expect( row.values ).to eq ['2']
-            end.once.ordered
-            expect( visitor ).to receive(:examples_table_row) do |row|
-              expect( row.number ).to eq 1
-              expect( row.values ).to eq ['a']
-            end.once.ordered
-            feature.describe_to(visitor)
-          end
-
-        end
-
-        context "a Scenario Outline with an empty examples table" do
-          source do
-            feature do
-              scenario_outline 'outline name' do
-                step 'passing <arg>'
-
-                examples do
-                end
-              end
-            end
-          end
-
-          it "creates an examples table node but no example table rows" do
-            allow( visitor ).to receive(:feature).and_yield(visitor)
-            allow( visitor ).to receive(:scenario_outline).and_yield(visitor)
-            allow( visitor ).to receive(:outline_step)
-            expect( visitor ).to receive(:examples_table).and_yield(visitor)
-            expect( visitor ).to receive(:examples_table_row).exactly(0).times
-            feature.describe_to(visitor)
-          end
-
-        end
-
-        context "a Scenario Outline with no Examples" do
-          source do
-            feature(language: 'not-a-language')
-          end
-          it "throws an error" do
-            expect { feature.describe_to(double.as_null_object) }.to raise_error(ParseError)
-          end
-        end
-      end
-    end
-  end
-end