orchestrated 0.0.4 → 0.0.5

data/README.markdown

@@ -5,7 +5,7 @@ The [delayed_job](https://github.com/collectiveidea/delayed_job) Ruby Gem provid
 
 By breaking up otherwise serial execution into multiple queued jobs, a program can be made more scalable. This sort of distributed queue-processing architecture has a long and successful history in data processing.
 
-Queuing works well for simple tasks. By simple we mean, the task can be done all at once, in one piece. It has no dependencies on other tasks. This works well for performing a file upload task in the background (to avoid tying up a Ruby virtual machine process/thread). More complex (compound) multi-part tasks, however, do not fit this model. Examples of complex (compound) tasks include:
+Queuing works well for simple tasks. By simple we mean the task can be done all at once, in one piece. It has no dependencies on other tasks. This works well for performing a file upload task in the background (to avoid tying up a Ruby virtual machine process/thread). More complex (compound) multi-part tasks, however, do not fit this model. Examples of complex (compound) tasks include:
 
 1. pipelined (multi-step) generation of complex PDF documents
 2. extract/transfer/load (ETL) jobs that may load thousands of database records
@@ -40,15 +40,15 @@ The API
 To orchestrate (methods) on your own classes you simply call ```acts_as_orchestrated``` in the class definition like this:
 
 ```ruby
-class StatementGenerator
+class Xform
 
   acts_as_orchestrated
 
-  def generate(statement_id)
+  def merge(many, one)
   ...
   end
 
-  def render(statement_id)
+  def load(stuff)
   ...
   end
 
@@ -109,7 +109,7 @@ See the completion_spec for examples of how to combine these different prerequis
 Key Concept: Orchestration State
 --------------------------------
 
-An orchestration can be in one of six (6) states:
+An orchestration can be in one of a few states:
 
 ![Alt text](https://github.com/paydici/orchestrated/raw/master/Orchestrated::Orchestration_state.png 'Orchestration States')
 

data/lib/orchestrated/completion.rb

@@ -72,7 +72,7 @@ module Orchestrated
       notify_dependents_of_completion
     end
     def prerequisite_canceled
-      notify_dependents_of_completion unless prerequisite_associations.without_states('canceled').exists?
+      notify_dependents_of_cancellation unless prerequisite_associations.without_states('canceled').exists?
     end
   end
   class OrchestrationCompletionShim < CompletionExpression

data/lib/orchestrated/dependency.rb

@@ -16,11 +16,11 @@ module Orchestrated
       event :prerequisite_canceled do
         transition :incomplete => :canceled
       end
-      after_transition any => :complete do |orchestration, transition|
-        orchestration.dependent.prerequisite_complete
+      after_transition any => :complete do |dependency, transition|
+        dependency.dependent.prerequisite_complete
       end
-      after_transition any => :canceled do |orchestration, transition|
-        orchestration.dependent.prerequisite_canceled
+      after_transition any => :canceled do |dependency, transition|
+        dependency.dependent.prerequisite_canceled
       end
     end
   end

data/lib/orchestrated/version.rb

@@ -1,3 +1,3 @@
 module Orchestrated
-  VERSION = "0.0.4"
+  VERSION = "0.0.5"
 end

data/spec/spec_helper.rb

@@ -84,6 +84,7 @@ require 'spec_helper_methods'
 require 'database_cleaner' # see comments below
 
 RSpec.configure do |config|
+
   # This standard Rails approach won't work in this project (which is not
   # _really_ a Rails app after all.
   #   config.use_transactional_fixtures = true
@@ -107,5 +108,14 @@ RSpec.configure do |config|
   #     --seed 1234
   config.order = "random"
 
+  # Use color in STDOUT
+  config.color_enabled = true
+
+  # Use color not only in STDOUT but also in pagers and files
+  config.tty = true
+
+  # Use the specified formatter
+  config.formatter = :progress # :documentation :progress, :html, :textmate
+
   config.include SpecHelperMethods
 end

data/spec/unit/cancellation_spec.rb

@@ -2,27 +2,42 @@ require 'spec_helper'
 
 require 'orchestrated'
 
-shared_examples_for 'cancellation:' do
+shared_context 'cancelling first prerequisite' do
   before(:each) do
-    @prerequisite.cancel!
+    first_prerequisite.cancel!
   end
+end
+shared_context 'cancelling all prerequisites' do
+  before(:each) do
+    first_prerequisite.cancel!
+    last_prerequisite.cancel!
+  end
+end
+shared_examples_for 'cancellation:' do
   it 'dependent should be in the "canceled" state' do
-    expect(@dependent.reload.canceled?).to be_true
+    expect(dependent.reload.canceled?).to be_true
+  end
+end
+shared_examples_for "cancellation doesn't (cancel):" do
+  it 'dependent not should be in the "canceled" state' do
+    expect(dependent.reload.canceled?).to be_false
   end
 end
-
 shared_examples_for 'cannot cancel:' do
-  it 'dependent should be in the "canceled" state' do
-    expect{@prerequisite.cancel!}.to raise_error(StateMachine::InvalidTransition)
+  it 'should raise an error when we try to cancel it' do
+    expect{@first_prerequisite.cancel!}.to raise_error(StateMachine::InvalidTransition)
   end
 end
 
 describe 'cancellation' do
+  attr_accessor :first_prerequisite, :last_prerequisite, :dependent
+  def dependent;@dependent;end
   context 'directly on an orchestration' do
     before(:each) do
-      @prerequisite = @dependent = First.new.orchestrated.do_first_thing(1)
+      @first_prerequisite = @dependent = First.new.orchestrated.do_first_thing(1)
     end
     context 'that is ready' do
+      include_context 'cancelling first prerequisite'
       it_should_behave_like 'cancellation:'
       it 'should never subsequently deliver the orchestrated message' do
         First.any_instance.should_not_receive(:do_first_thing)
@@ -31,36 +46,55 @@ describe 'cancellation' do
     end
     context 'that is succeeded' do
       before(:each) do
-        @prerequisite.orchestration.state = 'succeeded'
+        @first_prerequisite.orchestration.state = 'succeeded'
       end
       it_should_behave_like 'cannot cancel:'
     end
     context 'that is failed' do
       before(:each) do
-        @prerequisite.orchestration.state = 'failed'
+        @first_prerequisite.orchestration.state = 'failed'
       end
       it_should_behave_like 'cannot cancel:'
     end
     context 'that is canceled' do
       before(:each) do
-        @prerequisite.orchestration.state = 'canceled'
+        @first_prerequisite.orchestration.state = 'canceled'
       end
       it_should_behave_like 'cannot cancel:'
     end
   end
   context 'of an orchestration that is depended on directly' do
     before(:each) do
-      @dependent = Second.new.orchestrated( @prerequisite = First.new.orchestrated.do_first_thing(1)).do_second_thing(2)
+      @dependent = Second.new.orchestrated( @first_prerequisite = First.new.orchestrated.do_first_thing(1)).do_second_thing(2)
     end
+    include_context 'cancelling first prerequisite'
     it_should_behave_like 'cancellation:'
   end
   context 'of an orchestration that is depended on through a LastCompletion' do
     before(:each) do
       @dependent = Second.new.orchestrated(
         Orchestrated::LastCompletion.new <<
-          (@prerequisite = First.new.orchestrated.do_first_thing(1))
+          (@first_prerequisite = First.new.orchestrated.do_first_thing(1))
         ).do_second_thing(2)
     end
+    include_context 'cancelling first prerequisite'
     it_should_behave_like 'cancellation:'
   end
+  context 'of an orchestration that is depended on through a FirstCompletion with two prerequisites' do
+    before(:each) do
+      @dependent = Second.new.orchestrated(
+        Orchestrated::FirstCompletion.new <<
+          (@first_prerequisite = First.new.orchestrated.do_first_thing(3)) <<
+          (@last_prerequisite = First.new.orchestrated.do_first_thing(1))
+        ).do_second_thing(2)
+    end
+    context 'after first prerequisite is canceled' do
+      include_context 'cancelling first prerequisite'
+      it_should_behave_like "cancellation doesn't (cancel):"
+    end
+    context 'after last prerequisite is canceled' do
+      include_context 'cancelling all prerequisites'
+      it_should_behave_like "cancellation:"
+    end
+  end
 end

data/spec/unit/orchestrated_spec.rb

@@ -2,6 +2,16 @@ require 'spec_helper'
 
 require 'orchestrated'
 
+
+shared_examples_for 'orchestration accessing prerequisite and dependent' do
+  it 'should reach interest at prerequisite' do
+    expect(@orchestration.prerequisite).to eq(@interest)
+  end
+  it 'should reach completion at dependent' do
+    expect(@orchestration.dependent).to eq(@completion)
+  end
+end
+
 describe Orchestrated do
   context 'initializing' do
     it 'should not define orchestrated on Object' do
@@ -14,7 +24,7 @@ describe Orchestrated do
       expect(First.public_method_defined?(:orchestrated)).to be_true
     end
   end
-  context 'a new orchestrated object' do
+  context 'a new object' do
     let(:f){First.new}
     context 'responding to messages without orchestration' do
       let(:result){f.do_first_thing(2)} # 2 is a prime number
@@ -22,6 +32,49 @@ describe Orchestrated do
         expect(result).to eq(5 * 2)
       end
     end
+    # I don't trust the has_one associations inside Orchestration to work right with the STI Completion hierarchy
+    # after spec'ing this I see that ActiveRecord does indeed qualify the has_one lookup (both of them)
+    # with the "type" field yay!
+    context 'creating orchestrated' do
+      # TODO: reimplement the next three functions as Factory Girl factories!
+      def create_orchestration
+        Orchestrated::Orchestration.new.tap do |orchestration|
+          orchestration.handler = Orchestrated::Orchestration::Handler.new( f, :do_first_thing, [1])
+          orchestration.save!
+        end
+      end
+      def create_interest(orchestration, prerequisite=Orchestrated::Complete.new)
+        prerequisite.save!
+        Orchestrated::OrchestrationInterest.new.tap do |interest|
+            interest.prerequisite = prerequisite
+            interest.orchestration = orchestration
+            interest.save!
+        end
+      end
+      def create_completion(orchestration)
+        Orchestrated::OrchestrationCompletion.new.tap do |completion|
+          completion.orchestration = @orchestration
+          completion.save!
+        end
+      end
+      before(:each) do
+        @orchestration = create_orchestration
+      end
+      context 'with prerequisite created before dependent' do
+        before(:each) do
+          @interest = create_interest(@orchestration)
+          @completion = create_completion(@orchestration)
+        end
+        it_should_behave_like 'orchestration accessing prerequisite and dependent'
+      end
+      context 'with dependent created before prerequisite' do
+        before(:each) do
+          @completion = create_completion(@orchestration)
+          @interest = create_interest(@orchestration)
+        end
+        it_should_behave_like 'orchestration accessing prerequisite and dependent'
+      end
+    end
     context 'orchestrating with no prerequisites' do
       before(:each){@result = f.orchestrated.do_first_thing(2)}
       after(:each){DJ.clear_all_jobs}

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: orchestrated
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors: