Merge 0673d9f into 5d41017

lib/cucumber/core.rb

@@ -4,30 +4,31 @@
 require 'cucumber/core/gherkin/document'
 require 'cucumber/core/compiler'
 require 'cucumber/core/test/runner'
+require 'cucumber/messages'
 require 'gherkin/query'
 
 module Cucumber
   module Core
 
-    def execute(gherkin_documents, filters = [], event_bus = EventBus.new)
+    def execute(gherkin_documents, filters = [], event_bus = EventBus.new, id_generator = Cucumber::Messages::IdGenerator::Incrementing.new)
       yield event_bus if block_given?
       receiver = Test::Runner.new(event_bus)
-      compile gherkin_documents, receiver, filters
+      compile gherkin_documents, receiver, filters, event_bus, id_generator
       self
     end
 
-    def compile(gherkin_documents, last_receiver, filters = [], event_bus = EventBus.new)
+    def compile(gherkin_documents, last_receiver, filters = [], event_bus = EventBus.new, id_generator = Cucumber::Messages::IdGenerator::Incrementing.new)
       first_receiver = compose(filters, last_receiver)
       gherkin_query = ::Gherkin::Query.new
-      compiler = Compiler.new(first_receiver, gherkin_query)
-      parse gherkin_documents, compiler, event_bus, gherkin_query
+      compiler = Compiler.new(first_receiver, gherkin_query, id_generator, event_bus)
+      parse gherkin_documents, compiler, event_bus, gherkin_query, id_generator
       self
     end
 
     private
 
-    def parse(gherkin_documents, compiler, event_bus, gherkin_query)
-      parser = Core::Gherkin::Parser.new(compiler, event_bus, gherkin_query)
+    def parse(gherkin_documents, compiler, event_bus, gherkin_query, id_generator)
+      parser = Core::Gherkin::Parser.new(compiler, event_bus, gherkin_query, id_generator)
       gherkin_documents.each do |document|
         parser.document document
       end

lib/cucumber/core/compiler.rb

@@ -11,12 +11,14 @@ module Cucumber
   module Core
     # Compiles the Pickles into test cases
     class Compiler
-      attr_reader :receiver, :gherkin_query
-      private     :receiver, :gherkin_query
+      attr_reader :receiver, :gherkin_query, :id_generator
+      private     :receiver, :gherkin_query, :id_generator
 
-      def initialize(receiver, gherkin_query)
+      def initialize(receiver, gherkin_query, id_generator, event_bus = nil)
         @receiver = receiver
+        @id_generator = id_generator
         @gherkin_query = gherkin_query
+        @event_bus = event_bus
       end
 
       def pickle(pickle)
@@ -35,14 +37,18 @@ def create_test_case(pickle)
         uri = pickle.uri
         test_steps = pickle.steps.map { |step| create_test_step(step, uri) }
         lines = source_lines_for_pickle(pickle).sort.reverse
-        tags = pickle.tags.map { |tag| Test::Tag.new(Test::Location.new(uri, source_line_for_pickle_tag(tag)), tag.name) } # TODO: don't hardcode tag location
-        Test::Case.new(pickle.name, test_steps, Test::Location.new(uri, lines), tags, pickle.language)
+        tags = pickle.tags.map { |tag| Test::Tag.new(Test::Location.new(uri, source_line_for_pickle_tag(tag)), tag.name) }
+        test_case = Test::Case.new(id_generator.new_id, pickle.name, test_steps, Test::Location.new(uri, lines), tags, pickle.language)
+        @event_bus.test_case_created(test_case, pickle) unless @event_bus.nil?
+        test_case
       end
 
       def create_test_step(pickle_step, uri)
         lines = source_lines_for_pickle_step(pickle_step).sort.reverse
         multiline_arg = create_multiline_arg(pickle_step, uri)
-        Test::Step.new(pickle_step.text, Test::Location.new(uri, lines), multiline_arg)
+        step = Test::Step.new(id_generator.new_id, pickle_step.text, Test::Location.new(uri, lines), multiline_arg)
+        @event_bus.test_step_created(step, pickle_step) unless @event_bus.nil?
+        step
       end
 
       def create_multiline_arg(pickle_step, uri)

lib/cucumber/core/events.rb

@@ -12,6 +12,24 @@ class GherkinSourceParsed < Event.new(:gherkin_document)
 
       end
 
+      # Signals that a Test::Step was created from a PickleStep
+      class TestStepCreated < Event.new(:test_step, :pickle_step)
+        # The created test step
+        attr_reader :test_step
+
+        # The source pickle step
+        attr_reader :pickle_step
+      end
+
+      # Signals that a Test::Case was created from a Pickle
+      class TestCaseCreated < Event.new(:test_case, :pickle)
+        # The created test step
+        attr_reader :test_case
+
+        # The source pickle step
+        attr_reader :pickle
+      end
+
       # Signals that a {Test::Case} is about to be executed
       class TestCaseStarted < Event.new(:test_case)
 
@@ -56,6 +74,8 @@ class TestCaseFinished < Event.new(:test_case, :result)
       def self.registry
         build_registry(
           GherkinSourceParsed,
+          TestStepCreated,
+          TestCaseCreated,
           TestCaseStarted,
           TestStepStarted,
           TestStepFinished,

lib/cucumber/core/gherkin/parser.rb

@@ -7,13 +7,14 @@ module Gherkin
       ParseError = Class.new(StandardError)
 
       class Parser
-        attr_reader :receiver, :event_bus, :gherkin_query
-        private     :receiver, :event_bus, :gherkin_query
+        attr_reader :receiver, :event_bus, :gherkin_query, :id_generator
+        private     :receiver, :event_bus, :gherkin_query, :id_generator
 
-        def initialize(receiver, event_bus, gherkin_query)
+        def initialize(receiver, event_bus, gherkin_query, id_generator)
           @receiver = receiver
           @event_bus = event_bus
           @gherkin_query = gherkin_query
+          @id_generator = id_generator
         end
 
         def document(document)
@@ -38,7 +39,8 @@ def gherkin_options(document)
             default_dialect: document.language,
             include_source: false,
             include_gherkin_document: true,
-            include_pickles: true
+            include_pickles: true,
+            id_generator: id_generator
           }
         end
 

lib/cucumber/core/test/case.rb

@@ -7,10 +7,11 @@ module Cucumber
   module Core
     module Test
       class Case
-        attr_reader :name, :test_steps, :location, :tags, :language, :around_hooks
+        attr_reader :id, :name, :test_steps, :location, :tags, :language, :around_hooks
 
-        def initialize(name, test_steps, location, tags, language, around_hooks = [])
+        def initialize(id, name, test_steps, location, tags, language, around_hooks = [])
           raise ArgumentError.new("test_steps should be an Array but is a #{test_steps.class}") unless test_steps.is_a?(Array)
+          @id = id
           @name = name
           @test_steps = test_steps
           @location = location
@@ -35,11 +36,11 @@ def describe_to(visitor, *args)
         end
 
         def with_steps(test_steps)
-          self.class.new(name, test_steps, location, tags, language, around_hooks)
+          self.class.new(id, name, test_steps, location, tags, language, around_hooks)
         end
 
         def with_around_hooks(around_hooks)
-          self.class.new(name, test_steps, location, tags, language, around_hooks)
+          self.class.new(id, name, test_steps, location, tags, language, around_hooks)
         end
 
         def match_tags?(*expressions)

lib/cucumber/core/test/step.rb

@@ -8,10 +8,11 @@ module Cucumber
   module Core
     module Test
       class Step
-        attr_reader :text, :location, :multiline_arg
+        attr_reader :id, :text, :location, :multiline_arg
 
-        def initialize(text, location, multiline_arg = Test::EmptyMultilineArgument.new, action = Test::UndefinedAction.new(location))
+        def initialize(id, text, location, multiline_arg = Test::EmptyMultilineArgument.new, action = Test::UndefinedAction.new(location))
           raise ArgumentError if text.nil? || text.empty?
+          @id = id
           @text = text
           @location = location
           @multiline_arg = multiline_arg
@@ -35,7 +36,7 @@ def execute(*args)
         end
 
         def with_action(action_location = nil, &block)
-          self.class.new(text, location, multiline_arg, Test::Action.new(action_location, &block))
+          self.class.new(id, text, location, multiline_arg, Test::Action.new(action_location, &block))
         end
 
         def backtrace_line
@@ -56,8 +57,8 @@ def inspect
       end
 
       class HookStep < Step
-        def initialize(text, location, action)
-          super(text, location, Test::EmptyMultilineArgument.new, action)
+        def initialize(id, text, location, action)
+          super(id, text, location, Test::EmptyMultilineArgument.new, action)
         end
 
         def hook?

spec/cucumber/core/compiler_spec.rb

@@ -31,6 +31,57 @@ def self.stubs(*names)
       end
     end
 
+    context "when the event_bus is provided" do
+      let(:event_bus) { double }
+
+      before do
+        allow( event_bus ).to receive(:gherkin_source_parsed).and_return(nil)
+        allow( event_bus ).to receive(:test_case_created).and_return(nil)
+        allow( event_bus ).to receive(:test_step_created).and_return(nil)
+      end
+
+      it "emits a TestCaseCreated event with the created Test::Case and Pickle" do
+        gherkin_documents = [
+          gherkin do
+            feature do
+              scenario do
+                step 'passing'
+              end
+            end
+          end
+        ]
+
+        compile(gherkin_documents, event_bus) do | visitor |
+          allow( visitor ).to receive(:test_case)
+          allow( visitor ).to receive(:test_step)
+          allow( visitor ).to receive(:done)
+
+          expect( event_bus ).to receive(:test_case_created).once
+        end
+      end
+
+      it "emits a TestStepCreated event with the created Test::Step and PickleStep" do
+        gherkin_documents = [
+          gherkin do
+            feature do
+              scenario do
+                step 'passing'
+                step 'passing'
+              end
+            end
+          end
+        ]
+
+        compile(gherkin_documents, event_bus) do |visitor|
+          allow( visitor ).to receive(:test_case)
+          allow( visitor ).to receive(:test_step)
+          allow( visitor ).to receive(:done)
+
+          expect( event_bus ).to receive(:test_step_created).twice
+        end
+      end
+    end
+
     it "compiles a feature with a background" do
       gherkin_documents = [
         gherkin do
@@ -166,13 +217,20 @@ def self.stubs(*names)
       end
     end
 
-    def compile(gherkin_documents)
+    def compile(gherkin_documents, event_bus = nil)
       visitor = double
       allow( visitor ).to receive(:test_suite).and_yield(visitor)
       allow( visitor ).to receive(:test_case).and_yield(visitor)
+
+      if event_bus.nil?
+        event_bus = double
+        allow( event_bus ).to receive(:gherkin_source_parsed).and_return(nil)
+        allow( event_bus ).to receive(:test_case_created).and_return(nil)
+        allow( event_bus ).to receive(:test_step_created).and_return(nil)
+      end
+
       yield visitor
-      super(gherkin_documents, visitor)
+      super(gherkin_documents, visitor, [], event_bus)
     end
-
   end
 end

spec/cucumber/core/gherkin/parser_spec.rb

@@ -10,12 +10,14 @@ module Gherkin
         let(:receiver)  { double }
         let(:event_bus) { double }
         let(:gherkin_query) { double }
-        let(:parser)    { Parser.new(receiver, event_bus, gherkin_query) }
+        let(:id_generator) { double }
+        let(:parser)    { Parser.new(receiver, event_bus, gherkin_query, id_generator) }
         let(:visitor)   { double }
 
         before do
           allow( event_bus ).to receive(:gherkin_source_parsed)
           allow( gherkin_query ).to receive(:update)
+          allow( id_generator ).to receive(:new_id)
         end
 
         def parse

spec/cucumber/core/test/case_spec.rb

@@ -13,11 +13,12 @@ module Test
         include Core
         include Core::Gherkin::Writer
 
+        let(:id) { double }
         let(:name) { double }
         let(:location) { double }
         let(:tags) { double }
         let(:language) { double }
-        let(:test_case) { Test::Case.new(name, test_steps, location, tags, language) }
+        let(:test_case) { Test::Case.new(id, name, test_steps, location, tags, language) }
         let(:test_steps) { [double, double] }
 
         context 'describing itself' do
@@ -45,7 +46,7 @@ module Test
             expect( first_hook ).to receive(:describe_to).ordered.and_yield
             expect( second_hook ).to receive(:describe_to).ordered.and_yield
             around_hooks = [first_hook, second_hook]
-            Test::Case.new(name, [], location, tags, language, around_hooks).describe_to(visitor, double)
+            Test::Case.new(id, name, [], location, tags, language, around_hooks).describe_to(visitor, double)
           end
 
         end