light-service 0.7.0 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 20a9e0cfd0b42cb8c0fb35b808f099c50a7ca32f
-  data.tar.gz: d8d76249eafe1e4cdeb1830b8b13453905941b7a
+  metadata.gz: f66d801de921ff601005501d2aec87d3943138fc
+  data.tar.gz: 6c9ea24dac7c7500e05d5b99ca5898bcfe97fa7f
 SHA512:
-  metadata.gz: d117cd24d38771a808e1210877387d167a74ad9588c314e34db5903c7b86ded6fdf1760a8a11467051626ea286c017729f82b5f4fe70198d125973b8eb0cc011
-  data.tar.gz: e6aaf6e9b0605ad347ad290ef35c2fb9f9afb5a47676b3be01473dd9b57c54ca337c8a5ea5add5541363fecb1c06a187f93a156bb39bc5d72a5082b33172715b
+  metadata.gz: 5607646dacdc11ac1201ed7a6b5be6f963a43b3838263edc1909db4a032e92a051f3555ec71ea3006084d211c9b2dd8f12fc755ff9fc0889689ef9a9a7c68152
+  data.tar.gz: 0f42791e151e88a49a0018705c78ea1e1471df2f57f13c2fad886a25a28cc4bfa9126618a1aeee5df2760d0574a29655dd926d84d29edff4a5bab742b4993970

data/README.md

@@ -1,4 +1,4 @@
-![LightService](https://raw.github.com/adomokos/light-service/master/resources/light-service.png)
+![LightService](resources/light-service.png)
 
 [![Gem Version](https://img.shields.io/gem/v/light-service.svg)](https://rubygems.org/gems/light-service)
 [![Build Status](https://secure.travis-ci.org/adomokos/light-service.png)](http://travis-ci.org/adomokos/light-service)
@@ -36,7 +36,7 @@ end
 ```
 
 This controller violates [SRP](http://en.wikipedia.org/wiki/Single_responsibility_principle) all over.
-Also, imagine what would it take to test this beast.
+Also, imagine what it would take to test this beast.
 You could move the tax_percentage finders and calculations into the tax model,
 but then you'll make your model logic heavy.
 
@@ -50,19 +50,19 @@ Wouldn't it be nice to see this instead?
 
 ```ruby
 (
-  LooksUpTaxPercentageAction,
-  CalculatesOrderTaxAction,
-  ChecksFreeShippingAction
+  LooksUpTaxPercentage,
+  CalculatesOrderTax,
+  ChecksFreeShipping
 )
 ```
 
 This block of code should tell you the "story" of what's going on in this workflow.
 With the help of LightService you can write code this way. First you need an organizer object that sets up the actions in order
-and executes them one-by-one. Then you need to create the actions which will only have one method and will do only one thing.
+and executes them one-by-one. Then you need to create the actions with one method (that will do only one thing).
 
-This is how the organizer and actions interact with eachother:
+This is how the organizer and actions interact with each other:
 
-![LightService](https://raw.github.com/adomokos/light-service/master/resources/organizer_and_actions.png)
+![LightService](resources/organizer_and_actions.png)
 
 ```ruby
 class CalculatesTax
@@ -157,6 +157,7 @@ simple and elegant Rails code where I told the story of how LightService was ext
 * [Error Codes](#error-codes)
 * [Action Rollback](#action-rollback)
 * [Localizing Messages](#localizing-messages)
+* [Orchestrators](#orchestrators)
 
 ## Stopping the Series of Actions
 When nothing unexpected happens during the organizer's call, the returned `context` will be successful. Here is how you can check for this:
@@ -192,7 +193,7 @@ class SubmitsOrderAction
   expects :order, :mailer
 
   executed do |context|
-    unless context.order.submit_order_succeful?
+    unless context.order.submit_order_successful?
       context.fail!("Failed to submit the order")
       next context
     end
@@ -201,7 +202,7 @@ class SubmitsOrderAction
   end
 end
 ```
-![LightService](https://raw.github.com/adomokos/light-service/master/resources/fail_actions.png)
+![LightService](resources/fail_actions.png)
 
 In the example above the organizer called 4 actions. The first 2 actions got executed successfully. The 3rd had a failure, that pushed the context into a failure state and the 4th action was skipped.
 
@@ -221,7 +222,7 @@ class ChecksOrderStatusAction
   end
 end
 ```
-![LightService](https://raw.github.com/adomokos/light-service/master/resources/skip_actions.png)
+![LightService](resources/skip_actions.png)
 
 In the example above the organizer called 4 actions. The first 2 actions got executed successfully. The 3rd decided to skip the rest, the 4th action was not invoked. The context was successful.
 
@@ -316,7 +317,7 @@ class FooAction
 end
 ```
 
-Take a look at [this spec](https://github.com/adomokos/light-service/blob/master/spec/action_expects_and_promises_spec.rb) to see the refactoring in action.
+Take a look at [this spec](spec/action_expects_and_promises_spec.rb) to see the refactoring in action.
 
 ## Key Aliases
 The `aliases` macro sets up pairs of keys and aliases in an organizer. Actions can access the context using the aliases.
@@ -329,7 +330,7 @@ Say for example you have actions `AnAction` and `AnotherAction` that you've used
 class AnOrganizer
   extend LightService::Organizer
 
-  aliases my_key: :key_alias
+  aliases :my_key => :key_alias
 
   def self.call(order)
     with(:order => order).reduce(
@@ -492,7 +493,7 @@ Using the `rolled_back` macro is optional for the actions in the chain. You shou
 
 The actions are rolled back in reversed order from the point of failure starting with the action that triggered it.
 
-See [this](https://github.com/adomokos/light-service/blob/master/spec/acceptance/rollback_spec.rb) acceptance test to learn more about this functionality.
+See [this](spec/acceptance/rollback_spec.rb) acceptance test to learn more about this functionality.
 
 ## Localizing Messages
 By default LightService provides a mechanism for easily translating your error or success messages via I18n.  You can also provide your own custom localization adapter if your application's logic is more complex than what is shown here.
@@ -571,7 +572,96 @@ end
 
 To get the value of a `fail!` or `succeed!` message, simply call `#message` on the returned context.
 
+## Orchestrators
+
+The Organizer - Action combination works really well for simple use cases. However, as business logic gets more complex, or when LightService is used in an ETL workflow, the code that routes the different organizers becomes very complex and imperative. Let's look at a piece of code that does basic data transformations:
+
+```ruby
+class ExtractsTransformsLoadsData
+  def self.run(connection)
+    context = RetrievesConnectionInfo.call(connection)
+    context = PullsDataFromRemoteApi.call(context)
+
+    retrieved_items = context.retrieved_items
+    if retrieved_items.empty?
+      NotifiesEngineeringTeamAction.execute(context)
+    end
+
+    retrieved_items.each do |item|
+      context[:item] = item
+      TransformsData.call(context)
+    end
+
+    context = LoadsData.call(context)
+
+    SendsNotifications.call(context)
+  end
+end
+```
+
+The `LightService::Context` is initialized with the first action, that context is passed around among organizers and actions. This code is still simpler than many out there, but it feels very imperative: it has conditionals, iterators in it. Let's see how we could make it a bit more simpler with a declarative style:
+
+```ruby
+class ExtractsTransformsLoadsData
+  extend LightService::Orchestrator
+
+  def self.run(connection)
+    with(:connection => connection).reduce(steps)
+  end
+
+  def self.steps
+    [
+      RetrievesConnectionInfo,
+      PullsDataFromRemoteApi,
+      reduce_if(->(ctx) { ctx.retrieved_items.empty? }, [
+        NotifiesEngineeringTeamAction
+      ]),
+      iterate(:retrieved_item, [
+        TransformsData
+      ]),
+      LoadsData,
+      SendsNotifications
+    ]
+  end
+end
+```
+
+This code is much easier to reason about, it's less noisy and it captures the goal of LightService well: simple, declarative code that's easy to understand.
+
+Our convention for naming the public methods on the different items at different levels is this:
+```
+Orchestrators
+   |-> run - steps
+   Organizers
+       |-> call - actions
+       Actions
+           |-> execute
+```
+
+You can mix organizers with actions in the orchestrator steps, but mixing other organizers with actions in an organizer is discouraged for the sake of simplicity.
+
+The 5 different constructs an orchestrator can have:
+
+1. `reduce`
+2. `reduce_until`
+3. `reduce_if`
+4. `iterate`
+5. `execute`
+
+The `reduce` method needs no interaction, it behaves similarly to organizers' `reduce` method.
+
+`reduce_until` behaves like a while loop in imperative languages, it iterates until the provided predicate in the lambda evaluates to true. Take a look at [this acceptance test](spec/acceptance/orchestrator/reduce_until_spec.rb) to see how it's used.
+
+`reduce_if` will reduce the included organizers and/or actions if the predicate in the labmda evaulates to true. [This acceptance test](spec/acceptance/orchestrator/reduce_if_spec.rb) describes this functionality.
+
+`iterate` gives your iteration logic, the symbol you define there has to be in the context as a key. For example. to iterate over items you will use `iterate(:items)` in your steps, the context needs to have `items` as a key, otherwise it will fail. The orchestrator will singularize the collection name and will put the actual item into the context under that name. Remaining with the example above, each element will be accessible by the name `item` for the actions in the `iterate` steps. [This acceptance test](spec/acceptance/orchestrator/iterate_spec.rb) should provide you with an example.
+
+To take advantage of another organizer or action, you might need to tweak the context a bit. Let's say you have a hash, and you need to iterate over its values in a series of action. To alter the context and have the values assigned into a variable, you need to create a new action with 1 line of code in it. That seems a lot of seremony for a simple change. You can do that in a `execute` method like this `execute(->(ctx) { ctx[:some_values] = ctx.some_hash.values })`. [This test](spec/acceptance/orchestrator/execute_spec.rb) describes how you can use it.
+
+** Thanks to [@bwvoss](https://github.com/bwvoss) for writing most of the Orchestrators code, I only ported his changes to LS and submitted the PR.
+
 ## Requirements
+
 This gem requires ruby 2.x
 
 ## Installation

data/lib/light-service.rb

@@ -12,3 +12,4 @@ require 'light-service/organizer/with_reducer_log_decorator'
 require 'light-service/organizer/with_reducer_factory'
 require 'light-service/action'
 require 'light-service/organizer'
+require 'light-service/orchestrator'

data/lib/light-service/configuration.rb

@@ -1,6 +1,7 @@
 module LightService
   class Configuration
     class << self
+      attr_accessor :capture_errors
       attr_writer :logger, :localization_adapter
 
       def logger

data/lib/light-service/context.rb

@@ -49,6 +49,11 @@ module LightService
       @skip_all
     end
 
+    def reset_skip_all!
+      @message = nil
+      @skip_all = false
+    end
+
     def outcome
       msg = '`Context#outcome` attribute reader is ' \
             'DEPRECATED and will be removed'

data/lib/light-service/orchestrator.rb

@@ -0,0 +1,79 @@
+module LightService
+  module Orchestrator
+    def self.extended(base_class)
+      base_class.extend ClassMethods
+    end
+
+    module ClassMethods
+      def with(data = {})
+        @context = LightService::Context.make(data)
+        self
+      end
+
+      def reduce(steps, context = @context)
+        steps.each_with_object(context) do |step, ctx|
+          if step.respond_to?(:execute)
+            step.execute(ctx)
+          elsif step.respond_to?(:call)
+            step.call(ctx)
+          else
+            raise 'Pass either an action or organizer'
+          end
+        end
+      end
+
+      def reduce_until(condition_block, steps)
+        lambda do |ctx|
+          loop do
+            ctx = scoped_reduction(ctx, steps)
+            break if condition_block.call(ctx) || ctx.failure?
+          end
+
+          ctx
+        end
+      end
+
+      def reduce_if(condition_block, steps)
+        lambda do |ctx|
+          ctx = scoped_reduction(ctx, steps) if condition_block.call(ctx)
+          ctx
+        end
+      end
+
+      def execute(code_block)
+        lambda do |ctx|
+          ctx = code_block.call(ctx)
+          ctx
+        end
+      end
+
+      def iterate(collection_key, steps)
+        lambda do |ctx|
+          collection = ctx[collection_key]
+          item_key = collection_key.to_s.singularize.to_sym
+          collection.each do |item|
+            ctx[item_key] = item
+            ctx = scoped_reduction(ctx, steps)
+          end
+
+          ctx
+        end
+      end
+
+      private
+
+      def scoped_reduction(ctx, steps)
+        ctx.reset_skip_all! unless ctx.failure?
+        ctx =
+          if steps.is_a?(Array)
+            reduce(steps, ctx)
+          else
+            reduce([steps], ctx)
+          end
+        ctx.reset_skip_all! unless ctx.failure?
+
+        ctx
+      end
+    end
+  end
+end

data/lib/light-service/organizer/with_reducer.rb

@@ -48,7 +48,7 @@ module LightService
       def invoke_action(current_context, action)
         return action.execute(current_context) unless around_each_handler
 
-        around_each_handler.call(action, current_context) do
+        around_each_handler.call(current_context) do
           action.execute(current_context)
         end
       end

data/lib/light-service/version.rb

@@ -1,3 +1,3 @@
 module LightService
-  VERSION = "0.7.0".freeze
+  VERSION = "0.8.0".freeze
 end

data/light-service.gemspec

@@ -20,6 +20,6 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency("rspec", "~> 3.0")
   gem.add_development_dependency("simplecov", "~> 0.11")
-  gem.add_development_dependency("rubocop", "~> 0.36")
+  gem.add_development_dependency("rubocop", "~> 0.42")
   gem.add_development_dependency("pry", "~> 0.10")
 end

data/spec/acceptance/around_each_spec.rb

@@ -1,27 +1,19 @@
 require 'spec_helper'
 require 'test_doubles'
 
-describe "Executing arbitrary code around each action" do
-  def assert_before_action_execute_log
-    expect(MyLogger).to receive(:info)
-      .with(TestDoubles::AddsTwoActionWithFetch, :number => 0)
-  end
-
-  def assert_after_action_execute_log
-    expect(MyLogger).to receive(:info)
-      .with(TestDoubles::AddsTwoActionWithFetch, :number => 2)
-  end
-
-  it "can be used to log data" do
-    MyLogger = double
-    context = { :number => 0 }
-
-    assert_before_action_execute_log
-    assert_after_action_execute_log
+describe 'Executing arbitrary code around each action' do
+  it 'can be used to log data' do
+    context = { :number => 0, :logger => TestDoubles::TestLogger.new }
 
     result = TestDoubles::AroundEachOrganizer.call(context)
 
     expect(result.fetch(:number)).to eq(2)
+    expect(result[:logger].logs).to eq(
+      [{
+        :action => TestDoubles::AddsTwoActionWithFetch,
+        :before => 0,
+        :after => 2
+      }]
+    )
   end
 end
-

data/spec/acceptance/orchestrator/context_failure_and_skipping_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe LightService::Orchestrator do
+  class TestSkipState
+    extend LightService::Orchestrator
+    def self.run_skip_before
+      with(:number => 1).reduce([
+                                  TestDoubles::SkipAllAction,
+                                  reduce_until(->(ctx) { ctx.number == 3 },
+                                               TestDoubles::AddOneAction)
+                                ])
+    end
+
+    def self.run_skip_after
+      with(:number => 1).reduce([
+                                  TestDoubles::SkipAllAction,
+                                  reduce_until(->(ctx) { ctx.number == 3 }, [
+                                                 TestDoubles::AddOneAction,
+                                                 TestDoubles::SkipAllAction
+                                               ]),
+                                  TestDoubles::AddOneAction
+                                ])
+    end
+
+    def self.run_failure
+      with(:number => 1).reduce([
+                                  TestDoubles::FailureAction,
+                                  reduce_until(->(ctx) { ctx[:number] == 3 },
+                                               TestDoubles::AddOneAction),
+                                  TestDoubles::AddOneAction
+                                ])
+    end
+  end
+
+  it 'does not skip nested contexts' do
+    result = TestSkipState.run_skip_before
+
+    expect(result).to be_success
+    expect(result.number).to eq(3)
+  end
+
+  it 'does not skip after a nested context' do
+    result = TestSkipState.run_skip_after
+
+    expect(result).to be_success
+    expect(result.number).to eq(4)
+  end
+
+  it 'respects failure across all nestings' do
+    result = TestSkipState.run_failure
+
+    expect(result).to be_failure
+    expect(result[:number]).to eq(1)
+  end
+end

data/spec/acceptance/orchestrator/execute_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe LightService::Orchestrator do
+  class TestExecute
+    extend LightService::Orchestrator
+
+    def self.run(context)
+      with(context).reduce(steps)
+    end
+
+    def self.steps
+      [
+        TestDoubles::AddOneAction,
+        execute(->(ctx) { ctx.number += 1 }),
+        execute(->(ctx) { ctx[:something] = 'hello' }),
+        TestDoubles::AddOneAction
+      ]
+    end
+  end
+
+  it 'calls the lambda in the execute block using the context' do
+    result = TestExecute.run(:number => 0)
+
+    expect(result).to be_success
+    expect(result.number).to eq(3)
+    expect(result[:something]).to eq('hello')
+  end
+end

data/spec/acceptance/orchestrator/iterate_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe LightService::Orchestrator do
+  class TestIterate
+    extend LightService::Orchestrator
+
+    def self.run(context)
+      with(context).reduce([
+                             iterate(:numbers, [
+                                       TestDoubles::AddOneAction
+                                     ])
+                           ])
+    end
+
+    def self.run_single(context)
+      with(context).reduce([
+                             iterate(:numbers, TestDoubles::AddOneAction)
+                           ])
+    end
+  end
+
+  it 'reduces each item of a collection and singularizes the collection key' do
+    result = TestIterate.run(:numbers => [1, 2, 3, 4])
+
+    expect(result).to be_success
+    expect(result.number).to eq(5)
+  end
+
+  it 'accepts a single action or organizer' do
+    result = TestIterate.run_single(:numbers => [1, 2, 3, 4])
+
+    expect(result).to be_success
+    expect(result.number).to eq(5)
+  end
+end

data/spec/acceptance/orchestrator/organizer_action_combination_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe LightService::Orchestrator do
+  class TestReduce
+    extend LightService::Orchestrator
+
+    def self.run(context, steps)
+      with(context).reduce(steps)
+    end
+  end
+
+  it 'responds to both actions and organizers' do
+    result = TestReduce.run({ :number => 0 }, [
+                              TestDoubles::AddTwoOrganizer,
+                              TestDoubles::AddOneAction
+                            ])
+
+    expect(result).to be_success
+    expect(result.number).to eq(3)
+  end
+
+  it 'fails fast by skipping proceeding actions/organizers after failure' do
+    result = TestReduce.run({ :number => 0 }, [
+                              TestDoubles::AddTwoOrganizer,
+                              TestDoubles::FailureAction,
+                              TestDoubles::AddOneAction
+                            ])
+
+    expect(result).not_to be_success
+    expect(result.number).to eq(2)
+  end
+
+  it 'does not allow anything but actions and organizers' do
+    expect do
+      TestReduce.run({}, [double])
+    end.to raise_error(RuntimeError)
+  end
+end

data/spec/acceptance/orchestrator/reduce_if_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'test_doubles'
+
+describe LightService::Orchestrator do
+  class TestReduceIf
+    extend LightService::Orchestrator
+
+    def self.run(context)
+      with(context).reduce(steps)
+    end
+
+    def self.steps
+      [
+        TestDoubles::AddOneAction,
+        reduce_if(->(ctx) { ctx.number == 1 },
+                  TestDoubles::AddOneAction)
+      ]
+    end
+  end
+
+  it 'reduces if the block evaluates to true' do
+    result = TestReduceIf.run(:number => 0)
+
+    expect(result).to be_success
+    expect(result.number).to eq(2)
+  end
+
+  it 'does not reduce if the block evaluates to false' do
+    result = TestReduceIf.run(:number => 2)
+
+    expect(result).to be_success
+    expect(result.number).to eq(3)
+  end
+end

data/spec/acceptance/orchestrator/reduce_until_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'test_doubles'
+
+RSpec.describe LightService::Orchestrator do
+  class TestReduceUntil
+    extend LightService::Orchestrator
+
+    def self.run
+      with(:number => 1).reduce(steps)
+    end
+
+    def self.steps
+      [
+        reduce_until(->(ctx) { ctx.number == 3 },
+                     TestDoubles::AddOneAction)
+      ]
+    end
+  end
+
+  it 'reduces until the block evaluates to true' do
+    result = TestReduceUntil.run
+
+    expect(result).to be_success
+    expect(result.number).to eq(3)
+  end
+end

data/spec/organizer/with_reducer_spec.rb

@@ -22,7 +22,7 @@ describe LightService::Organizer::WithReducer do
   it "executes a handler around each action and continues reducing" do
     expect(action1).to receive(:execute).with(context).and_return(context)
     expect(TestDoubles::AroundEachNullHandler).to receive(:call)
-      .with(action1, context).and_yield
+      .with(context).and_yield
 
     result = described_class.new.with(context)
                             .around_each(TestDoubles::AroundEachNullHandler)

data/spec/test_doubles.rb

@@ -1,17 +1,76 @@
 # A collection of Action and Organizer dummies used in specs
 
 module TestDoubles
+  class RollbackAction
+    extend LightService::Action
+    executed(&:fail_with_rollback!)
+  end
+
+  class RaiseErrorAction
+    extend LightService::Action
+    executed do |_ctx|
+      raise 'A problem has occured.'
+    end
+  end
+
+  class RaiseAnotherErrorAction
+    extend LightService::Action
+    executed do |_ctx|
+      raise 'More problems'
+    end
+  end
+
+  class SkipAllAction
+    extend LightService::Action
+    executed(&:skip_all!)
+  end
+
+  class FailureAction
+    extend LightService::Action
+    executed(&:fail!)
+  end
+
+  class AddOneAction
+    extend LightService::Action
+    expects :number
+    promises :number
+
+    executed do |ctx|
+      ctx.number += 1
+      ctx.message = 'Added 1'
+    end
+  end
+
+  class AddTwoOrganizer
+    extend LightService::Organizer
+    def self.call(context)
+      with(context).reduce([AddOneAction, AddOneAction])
+    end
+  end
+
   class AroundEachNullHandler
     def self.call(_action, _context)
       yield
     end
   end
 
+  class TestLogger
+    attr_accessor :logs
+    def initialize
+      @logs = []
+    end
+  end
+
   class AroundEachLoggerHandler
-    def self.call(action, context)
-      MyLogger.info(action, context)
+    def self.call(context)
+      before_number = context[:number]
       result = yield
-      MyLogger.info(action, context)
+
+      context[:logger].logs << {
+        :action => context.current_action,
+        :before => before_number,
+        :after => result[:number]
+      }
 
       result
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: light-service
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Attila Domokos
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-14 00:00:00.000000000 Z
+date: 2017-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.36'
+        version: '0.42'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.36'
+        version: '0.42'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -111,6 +111,7 @@ files:
 - lib/light-service/context/key_verifier.rb
 - lib/light-service/errors.rb
 - lib/light-service/localization_adapter.rb
+- lib/light-service/orchestrator.rb
 - lib/light-service/organizer.rb
 - lib/light-service/organizer/with_reducer.rb
 - lib/light-service/organizer/with_reducer_factory.rb
@@ -127,6 +128,12 @@ files:
 - spec/acceptance/log_from_organizer_spec.rb
 - spec/acceptance/message_localization_spec.rb
 - spec/acceptance/not_having_call_method_warning_spec.rb
+- spec/acceptance/orchestrator/context_failure_and_skipping_spec.rb
+- spec/acceptance/orchestrator/execute_spec.rb
+- spec/acceptance/orchestrator/iterate_spec.rb
+- spec/acceptance/orchestrator/organizer_action_combination_spec.rb
+- spec/acceptance/orchestrator/reduce_if_spec.rb
+- spec/acceptance/orchestrator/reduce_until_spec.rb
 - spec/acceptance/rollback_spec.rb
 - spec/action_expected_keys_spec.rb
 - spec/action_expects_and_promises_spec.rb
@@ -178,6 +185,12 @@ test_files:
 - spec/acceptance/log_from_organizer_spec.rb
 - spec/acceptance/message_localization_spec.rb
 - spec/acceptance/not_having_call_method_warning_spec.rb
+- spec/acceptance/orchestrator/context_failure_and_skipping_spec.rb
+- spec/acceptance/orchestrator/execute_spec.rb
+- spec/acceptance/orchestrator/iterate_spec.rb
+- spec/acceptance/orchestrator/organizer_action_combination_spec.rb
+- spec/acceptance/orchestrator/reduce_if_spec.rb
+- spec/acceptance/orchestrator/reduce_until_spec.rb
 - spec/acceptance/rollback_spec.rb
 - spec/action_expected_keys_spec.rb
 - spec/action_expects_and_promises_spec.rb