Store in Result the embeddings returned by a step

lib/cucumber/core/test/action.rb

@@ -3,6 +3,7 @@
 require 'cucumber/core/test/timer'
 require 'cucumber/core/test/result'
 require 'cucumber/core/test/location'
+require 'cucumber/core/test/invoke_result'
 
 module Cucumber
   module Core
@@ -21,8 +22,13 @@ def skip(*)
 
         def execute(*args)
           @timer.start
-          @block.call(*args)
-          passed
+          invoke_result = @block.call(*args)
+
+          case invoke_result
+          when PassedInvokeResult; then passed(invoke_result.embeddings)
+          when FailedInvokeResult; then failed(invoke_result.exception, invoke_result.embeddings)
+          else passed
+          end
         rescue Result::Raisable => exception
           exception.with_duration(@timer.duration)
         rescue Exception => exception
@@ -39,12 +45,12 @@ def inspect
 
         private
 
-        def passed
-          Result::Passed.new(@timer.duration)
+        def passed(embeddings = [])
+          Result::Passed.new(@timer.duration, embeddings)
         end
 
-        def failed(exception)
-          Result::Failed.new(@timer.duration, exception)
+        def failed(exception, embeddings = [])
+          Result::Failed.new(@timer.duration, exception, embeddings)
         end
 
         def skipped

lib/cucumber/core/test/invoke_result.rb

@@ -0,0 +1,23 @@
+module Cucumber
+  module Core
+    module Test
+      class InvokeResult
+        attr_reader :embeddings
+        def initialize(embeddings = [])
+          @embeddings = embeddings
+        end
+      end
+
+      class PassedInvokeResult < InvokeResult
+      end
+
+      class FailedInvokeResult < InvokeResult
+        attr_reader :exception
+        def initialize(exception, embeddings = [])
+          super(embeddings)
+          @exception = exception
+        end
+      end
+    end
+  end
+end

lib/cucumber/core/test/result.rb

@@ -54,19 +54,22 @@ def to_message
         class Passed
           include Result.query_methods :passed
           attr_accessor :duration
+          attr_reader :embeddings
 
           def self.ok?(be_strict = false)
             true
           end
 
-          def initialize(duration)
+          def initialize(duration, embeddings = [])
             raise ArgumentError unless duration
             @duration = duration
+            @embeddings = embeddings
           end
 
           def describe_to(visitor, *args)
             visitor.passed(*args)
             visitor.duration(duration, *args)
+            @embeddings.each { |e| visitor.embed(e['src'], e['mime_type'], e['label']) }
             self
           end
 
@@ -98,22 +101,25 @@ class Failed
           include Result.query_methods :failed
 
           attr_reader :duration, :exception
+          attr_reader :embeddings
 
           def self.ok?(be_strict = false)
             false
           end
 
-          def initialize(duration, exception)
+          def initialize(duration, exception, embeddings = [])
             raise ArgumentError unless duration
             raise ArgumentError unless exception
             @duration = duration
             @exception = exception
+            @embeddings = embeddings
           end
 
           def describe_to(visitor, *args)
             visitor.failed(*args)
             visitor.duration(duration, *args)
             visitor.exception(exception, *args) if exception
+            @embeddings.each { |e| visitor.embed(e['src'], e['mime_type'], e['label']) }
             self
           end
 
@@ -140,7 +146,7 @@ def ok?(be_strict = nil)
           end
 
           def with_duration(new_duration)
-            self.class.new(new_duration, exception)
+            self.class.new(new_duration, exception, embeddings)
           end
 
           def with_appended_backtrace(step)
@@ -149,7 +155,7 @@ def with_appended_backtrace(step)
           end
 
           def with_filtered_backtrace(filter)
-            self.class.new(duration, filter.new(exception.dup).exception)
+            self.class.new(duration, filter.new(exception.dup).exception, embeddings)
           end
         end
 
@@ -367,6 +373,10 @@ def duration(duration)
             self
           end
 
+          def embed(*)
+            self
+          end
+
           def total(for_status = nil)
             if for_status
               @totals.fetch(for_status) { 0 }

lib/cucumber/core/test/runner.rb

@@ -90,6 +90,10 @@ def duration(step_duration, step_result)
             self
           end
 
+          def embed(*)
+            self
+          end
+
           attr_reader :status
           private :status
 

spec/cucumber/core/test/action_spec.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 require 'cucumber/core/test/action'
 require 'cucumber/core/test/duration_matcher'
+require 'cucumber/core/test/invoke_result'
 
 module Cucumber
   module Core
@@ -46,15 +47,18 @@ module Test
 
           it "returns a passed result if the block doesn't fail" do
             action = Action.new {}
-            expect( action.execute ).to be_passed
+            result = action.execute
+            expect( result            ).to be_passed
+            expect( result.embeddings ).to be_empty
           end
 
           it "returns a failed result when the block raises an error" do
             exception = StandardError.new
             action = Action.new { raise exception }
             result = action.execute
-            expect( result ).to be_failed
-            expect( result.exception ).to eq exception
+            expect( result            ).to be_failed
+            expect( result.exception  ).to eq exception
+            expect( result.embeddings ).to be_empty
           end
 
           it "yields the args passed to #execute to the block" do
@@ -89,6 +93,24 @@ module Test
             expect( result.message ).to eq "new step"
           end
 
+          it "returns a passed result if the block returns a PassedInvokeResult" do
+            embeddings = [double]
+            action = Action.new { PassedInvokeResult.new(embeddings) }
+            result = action.execute
+            expect( result            ).to be_passed
+            expect( result.embeddings ).to eq embeddings
+          end
+
+          it "returns a failed result when the block returns a FailedInvokeResult" do
+            exception = StandardError.new
+            embeddings = [double]
+            action = Action.new { FailedInvokeResult.new(exception, embeddings) }
+            result = action.execute
+            expect( result            ).to be_failed
+            expect( result.exception  ).to eq exception
+            expect( result.embeddings ).to eq embeddings
+          end
+
           context "recording the duration" do
             before do
               allow( Timer::MonotonicTime ).to receive(:time_in_nanoseconds).and_return(525702744080000, 525702744080001)