cucumber 2.99.0 → 3.0.0.pre.1

data/lib/cucumber/events/finished_testing.rb

@@ -1,9 +0,0 @@
-module Cucumber
-  module Events
-
-    # Event fired after aall test cases have finished executing
-    class FinishedTesting
-    end
-
-  end
-end

data/lib/cucumber/formatter/event_bus_report.rb

@@ -1,38 +0,0 @@
-module Cucumber
-  module Formatter
-
-    # Adapter between Cucumber::Core::Test::Runner's Report API and 
-    # Cucumber's event bus
-    class EventBusReport
-      attr_reader :config
-      private :config
-
-      def initialize(config)
-        @config = config
-      end
-
-      def before_test_case(test_case)
-        @config.notify Events::BeforeTestCase.new(test_case)
-        @test_case = test_case
-      end
-
-      def before_test_step(test_step)
-        @config.notify Events::BeforeTestStep.new(@test_case, test_step)
-      end
-
-      def after_test_step(test_step, result)
-        @config.notify Events::AfterTestStep.new(@test_case, test_step, result)
-      end
-
-      def after_test_case(test_case, result)
-        @config.notify Events::AfterTestCase.new(test_case, result)
-      end
-
-      def done
-        @config.notify Events::FinishedTesting.new
-      end
-    end
-
-  end
-end
-

data/spec/cucumber/events/bus_spec.rb

@@ -1,94 +0,0 @@
-require "cucumber/events/bus"
-
-module Cucumber
-  module Events
-    class TestEvent
-    end
-
-    class AnotherTestEvent
-    end
-
-    describe Bus do
-      let(:bus) { Bus.new(Cucumber::Events) }
-      let(:test_event) { TestEvent.new }
-      let(:another_test_event) { AnotherTestEvent.new }
-
-      it "calls subscriber with event payload" do
-        received_payload = nil
-        bus.register(TestEvent) do |event|
-          received_payload = event
-        end
-
-        bus.notify test_event
-
-        expect(received_payload).to eq(test_event)
-      end
-
-      it "does not call subscribers for other events" do
-        handler_called = false
-        bus.register(TestEvent) do |event|
-          handler_called = true
-        end
-
-        bus.notify another_test_event
-
-        expect(handler_called).to eq(false)
-      end
-
-      it "broadcasts to multiple subscribers" do
-        received_events = []
-        bus.register(TestEvent) do |event|
-          received_events << event
-        end
-        bus.register(TestEvent) do |event|
-          received_events << event
-        end
-
-        bus.notify test_event
-
-        expect(received_events.length).to eq 2
-        expect(received_events).to all eq test_event
-      end
-
-      it "allows subscription by string" do
-        received_payload = nil
-        bus.register('Cucumber::Events::TestEvent') do |event|
-          received_payload = event
-        end
-
-        bus.notify test_event
-
-        expect(received_payload).to eq(test_event)
-      end
-
-      it "allows subscription by symbol (for events in the Cucumber::Events namespace)" do
-        received_payload = nil
-        bus.register(:test_event) do |event|
-          received_payload = event
-        end
-
-        bus.notify test_event
-
-        expect(received_payload).to eq(test_event)
-      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
-        bus.register(TestEvent, handler)
-
-        bus.notify test_event
-
-        expect(handler.received_payload).to eq test_event
-      end
-
-    end
-  end
-end

data/spec/cucumber/formatter/event_bus_report_spec.rb

@@ -1,88 +0,0 @@
-require 'cucumber/configuration'
-require 'cucumber/runtime'
-require 'cucumber/formatter/spec_helper'
-require 'cucumber/formatter/event_bus_report'
-
-module Cucumber
-  module Formatter
-    describe EventBusReport do
-      extend SpecHelperDsl
-      include SpecHelper
-
-      context "With no options" do
-        let(:config) { Cucumber::Configuration.new }
-
-        before(:each) do
-          @formatter = EventBusReport.new(config)
-        end
-
-        describe "given a single feature" do
-
-          describe "a scenario with a single passing step" do
-            define_feature <<-FEATURE
-          Feature:
-            Scenario: Test Scenario
-              Given passing
-            FEATURE
-
-            define_steps do
-              Given(/pass/) {}
-            end
-
-            it "emits a BeforeTestCase event" do
-              received_event = nil
-              config.on_event Cucumber::Events::BeforeTestCase do |event|
-                received_event = event
-              end
-              run_defined_feature
-              expect(received_event.test_case.name).to eq "Test Scenario"
-            end
-
-            it "emits a BeforeTestStep event" do
-              received_event = nil
-              config.on_event Cucumber::Events::BeforeTestStep do |event|
-                received_event = event
-              end
-              run_defined_feature
-              expect(received_event.test_case.name).to eq "Test Scenario"
-              expect(received_event.test_step.name).to eq "passing"
-            end
-
-            it "emits an AfterTestStep event with a passed result" do
-              received_event = nil
-              config.on_event Cucumber::Events::AfterTestStep do |event|
-                received_event = event
-              end
-              run_defined_feature
-              expect(received_event.test_case.name).to eq "Test Scenario"
-              expect(received_event.test_step.name).to eq "passing"
-              expect(received_event.result).to be_passed
-            end
-
-            it "emits an AfterTestCase event with a passed result" do
-              received_event = nil
-              config.on_event Cucumber::Events::AfterTestCase do |event|
-                received_event = event
-              end
-              run_defined_feature
-              expect(received_event.test_case.name).to eq "Test Scenario"
-              expect(received_event.result).to be_passed
-            end
-
-            it "emits a Done event when the test run is finished" do
-              received_event = nil
-              config.on_event Cucumber::Events::FinishedTesting do |event|
-                received_event = event
-              end
-              run_defined_feature
-              expect(received_event).not_to be_nil
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-
-

data/spec/cucumber_spec.rb

@@ -1,39 +0,0 @@
-require 'cucumber'
-
-describe Cucumber do
-
-  # Implementation is backported from ruby 2.0 when cucumber is used on ruby 1.9.
-  # The tests will run on all implementations to ensure we have the same
-  # feature set.
-  describe 'Hash' do
-    it "converts nil to empty {}" do
-      expect(Cucumber::Hash(nil)).to eq({})
-    end
-
-    it "converts [] to {}" do
-      expect(Cucumber::Hash([])).to eq({})
-    end
-
-    it "converts a hash to an equivalent hash" do
-      original = {:a => 1, :b => 2}
-      expect(Cucumber::Hash(original)).to eq({a: 1, b: 2})
-    end
-
-    it "converts an object with a to_hash method" do
-      original = Object.new
-      def original.to_hash
-        {key: "value"}
-      end
-
-      expect(Cucumber::Hash(original)).to eq({key: "value"})
-    end
-
-    it "raises a TypeError for an object that does not have .to_hash" do
-      original = %w(cannot convert to hash)
-
-      expect { Cucumber::Hash(original) }.to raise_error TypeError
-    end
-  end
-end
-
-