cucumber-core 10.1.1 → 11.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,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