taskinator 0.2.0 → 0.3.0

data/spec/taskinator/task_spec.rb

@@ -4,11 +4,19 @@ describe Taskinator::Task do
 
   let(:definition) { TestDefinition }
 
-  describe "Base" do
+  let(:process) do
+    Class.new(Taskinator::Process) do
+      include ProcessMethods
+    end.new(definition)
+  end
 
-    let(:process) { Class.new(Taskinator::Process).new(definition) }
+  describe "Base" do
 
-    subject { Class.new(Taskinator::Task).new(process) }
+    subject do
+      Class.new(Taskinator::Task) do
+        include TaskMethods
+      end.new(process)
+    end
 
     describe "#initialize" do
       it { expect(subject.process).to_not be_nil }
@@ -45,9 +53,9 @@ describe Taskinator::Task do
     end
 
     describe "#current_state" do
-      it { expect(subject).to be_a(::Workflow)  }
+      it { expect(subject).to be_a(Taskinator::Workflow)  }
       it { expect(subject.current_state).to_not be_nil }
-      it { expect(subject.current_state.name).to eq(:initial) }
+      it { expect(subject.current_state).to eq(:initial) }
     end
 
     describe "workflow" do
@@ -59,7 +67,7 @@ describe Taskinator::Task do
         }
         it {
           subject.enqueue!
-          expect(subject.current_state.name).to eq(:enqueued)
+          expect(subject.current_state).to eq(:enqueued)
         }
       end
 
@@ -71,7 +79,7 @@ describe Taskinator::Task do
         }
         it {
           subject.start!
-          expect(subject.current_state.name).to eq(:processing)
+          expect(subject.current_state).to eq(:processing)
         }
       end
 
@@ -81,7 +89,7 @@ describe Taskinator::Task do
           expect(subject).to receive(:complete)
           subject.start!
           subject.complete!
-          expect(subject.current_state.name).to eq(:completed)
+          expect(subject.current_state).to eq(:completed)
         }
       end
 
@@ -96,8 +104,8 @@ describe Taskinator::Task do
         }
         it {
           subject.start!
-          subject.fail!
-          expect(subject.current_state.name).to eq(:failed)
+          subject.fail!(StandardError.new)
+          expect(subject.current_state).to eq(:failed)
         }
       end
 
@@ -106,7 +114,7 @@ describe Taskinator::Task do
         it {
           process.start!
           process.pause!
-          expect(subject.paused?).to be
+          expect(subject.paused?).to eq(true)
         }
       end
 
@@ -139,6 +147,8 @@ describe Taskinator::Task do
         expect(visitor).to receive(:visit_task_reference).with(:next)
         expect(visitor).to receive(:visit_args).with(:options)
         expect(visitor).to receive(:visit_attribute).with(:queue)
+        expect(visitor).to receive(:visit_attribute_time).with(:created_at)
+        expect(visitor).to receive(:visit_attribute_time).with(:updated_at)
 
         subject.accept(visitor)
       }
@@ -152,14 +162,11 @@ describe Taskinator::Task do
   end
 
   describe Taskinator::Task::Step do
-    it_should_behave_like "a task", Taskinator::Task::Step do
-      let(:process) { Class.new(Taskinator::Process).new(definition) }
-      let(:task) { Taskinator::Task.define_step_task(process, :do_task, {:a => 1, :b => 2}) }
-    end
 
-    let(:process) { Class.new(Taskinator::Process).new(definition) }
     subject { Taskinator::Task.define_step_task(process, :do_task, {:a => 1, :b => 2}) }
 
+    it_should_behave_like "a task", Taskinator::Task::Step
+
     describe ".define_step_task" do
       it "sets the queue to use" do
         task = Taskinator::Task.define_step_task(process, :do_task, {:a => 1, :b => 2}, :queue => :foo)
@@ -197,8 +204,7 @@ describe Taskinator::Task do
           expect(args.first).to eq('taskinator.task.enqueued')
         end
 
-        # temporary subscription
-        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
+        TestInstrumenter.subscribe(instrumentation_block, /taskinator.task/) do
           subject.enqueue!
         end
       end
@@ -206,7 +212,7 @@ describe Taskinator::Task do
 
     describe "#start!" do
       before do
-        expect(process).to receive(:task_completed).with(subject)
+        allow(process).to receive(:task_completed).with(subject)
       end
 
       it "invokes executor" do
@@ -246,24 +252,28 @@ describe Taskinator::Task do
         instrumentation_block = SpecSupport::Block.new
 
         expect(instrumentation_block).to receive(:call) do |*args|
-          expect(args.first).to eq('taskinator.task.started')
+          expect(args.first).to eq('taskinator.task.processing')
         end
 
-        # special case, since when the method returns, the task is considered to be complete
         expect(instrumentation_block).to receive(:call) do |*args|
           expect(args.first).to eq('taskinator.task.completed')
         end
 
-        # temporary subscription
-        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
+        TestInstrumenter.subscribe(instrumentation_block) do
           subject.start!
         end
       end
     end
 
     describe "#complete" do
+      it "notifies parent process" do
+        expect(process).to receive(:task_completed).with(subject)
+
+        subject.complete!
+      end
+
       it "is instrumented" do
-        allow(process).to receive(:task_completed)
+        allow(process).to receive(:task_completed).with(subject)
 
         instrumentation_block = SpecSupport::Block.new
 
@@ -271,8 +281,7 @@ describe Taskinator::Task do
           expect(args.first).to eq('taskinator.task.completed')
         end
 
-        # temporary subscription
-        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
+        TestInstrumenter.subscribe(instrumentation_block, /taskinator.task/) do
           subject.complete!
         end
       end
@@ -294,6 +303,8 @@ describe Taskinator::Task do
         expect(visitor).to receive(:visit_attribute).with(:method)
         expect(visitor).to receive(:visit_args).with(:args)
         expect(visitor).to receive(:visit_attribute).with(:queue)
+        expect(visitor).to receive(:visit_attribute_time).with(:created_at)
+        expect(visitor).to receive(:visit_attribute_time).with(:updated_at)
 
         subject.accept(visitor)
       }
@@ -311,14 +322,20 @@ describe Taskinator::Task do
       end
     end
 
-    it_should_behave_like "a task", Taskinator::Task::Job do
-      let(:process) { Class.new(Taskinator::Process).new(definition) }
-      let(:task) { Taskinator::Task.define_job_task(process, TestJob, {:a => 1, :b => 2}) }
+    class TestJobClass
+      def perform(*args)
+      end
+    end
+
+    module TestJobModule
+      def self.perform(*args)
+      end
     end
 
-    let(:process) { Class.new(Taskinator::Process).new(definition) }
     subject { Taskinator::Task.define_job_task(process, TestJob, {:a => 1, :b => 2}) }
 
+    it_should_behave_like "a task", Taskinator::Task::Job
+
     describe ".define_job_task" do
       it "sets the queue to use" do
         task = Taskinator::Task.define_job_task(process, TestJob, {:a => 1, :b => 2}, :queue => :foo)
@@ -330,7 +347,7 @@ describe Taskinator::Task do
       it {
         expect {
           subject.enqueue!
-        }.to change { Taskinator.queue.jobs.length }.by(1)
+        }.to change { Taskinator.queue.tasks.length }.by(1)
       }
 
       it "is instrumented" do
@@ -340,33 +357,36 @@ describe Taskinator::Task do
           expect(args.first).to eq('taskinator.task.enqueued')
         end
 
-        # temporary subscription
-        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
+        TestInstrumenter.subscribe(instrumentation_block, /taskinator.task/) do
           subject.enqueue!
         end
       end
     end
 
-    describe "#perform" do
-      before do
-        expect(process).to receive(:task_completed).with(subject)
-      end
-
+    describe "#start" do
       it {
-        block = SpecSupport::Block.new
-        expect(block).to receive(:call).with(TestJob, {:a => 1, :b => 2})
+        task = Taskinator::Task.define_job_task(process, TestJobClass, {:a => 1, :b => 2})
+        expect(process).to receive(:task_completed).with(task)
+        expect_any_instance_of(TestJobClass).to receive(:perform).with({:a => 1, :b => 2})
+        task.start!
+      }
 
-        subject.perform(&block)
+      it {
+        task = Taskinator::Task.define_job_task(process, TestJobModule, {:a => 1, :b => 2})
+        expect(process).to receive(:task_completed).with(task)
+        expect(TestJobModule).to receive(:perform).with({:a => 1, :b => 2})
+        task.start!
       }
 
       it "is instrumented" do
-        block = SpecSupport::Block.new
-        allow(block).to receive(:call).with(TestJob, {:a => 1, :b => 2})
+        allow(process).to receive(:task_completed).with(subject)
+
+        allow(TestJob).to receive(:perform).with({:a => 1, :b => 2})
 
         instrumentation_block = SpecSupport::Block.new
 
         expect(instrumentation_block).to receive(:call) do |*args|
-          expect(args.first).to eq('taskinator.task.started')
+          expect(args.first).to eq('taskinator.task.processing')
         end
 
         # special case, since when the method returns, the task is considered to be complete
@@ -374,16 +394,21 @@ describe Taskinator::Task do
           expect(args.first).to eq('taskinator.task.completed')
         end
 
-        # temporary subscription
-        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
-          subject.perform(&block)
+        TestInstrumenter.subscribe(instrumentation_block, /taskinator.task/) do
+          subject.start!
         end
       end
     end
 
     describe "#complete" do
+      it "notifies parent process" do
+        expect(process).to receive(:task_completed).with(subject)
+
+        subject.complete!
+      end
+
       it "is instrumented" do
-        allow(process).to receive(:task_completed)
+        allow(process).to receive(:task_completed).with(subject)
 
         instrumentation_block = SpecSupport::Block.new
 
@@ -391,8 +416,7 @@ describe Taskinator::Task do
           expect(args.first).to eq('taskinator.task.completed')
         end
 
-        # temporary subscription
-        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
+        TestInstrumenter.subscribe(instrumentation_block, /taskinator.task/) do
           subject.complete!
         end
       end
@@ -414,6 +438,8 @@ describe Taskinator::Task do
         expect(visitor).to receive(:visit_type).with(:job)
         expect(visitor).to receive(:visit_args).with(:args)
         expect(visitor).to receive(:visit_attribute).with(:queue)
+        expect(visitor).to receive(:visit_attribute_time).with(:created_at)
+        expect(visitor).to receive(:visit_attribute_time).with(:updated_at)
 
         subject.accept(visitor)
       }
@@ -425,16 +451,17 @@ describe Taskinator::Task do
   end
 
   describe Taskinator::Task::SubProcess do
-    it_should_behave_like "a task", Taskinator::Task::SubProcess do
-      let(:process) { Class.new(Taskinator::Process).new(definition) }
-      let(:sub_process) { Class.new(Taskinator::Process).new(definition) }
-      let(:task) { Taskinator::Task.define_sub_process_task(process, sub_process) }
+
+    let(:sub_process) do
+      Class.new(Taskinator::Process) do
+        include ProcessMethods
+      end.new(definition)
     end
 
-    let(:process) { Class.new(Taskinator::Process).new(definition) }
-    let(:sub_process) { Class.new(Taskinator::Process).new(definition) }
     subject { Taskinator::Task.define_sub_process_task(process, sub_process) }
 
+    it_should_behave_like "a task", Taskinator::Task::SubProcess
+
     describe ".define_sub_process_task" do
       it "sets the queue to use" do
         task = Taskinator::Task.define_sub_process_task(process, sub_process, :queue => :foo)
@@ -463,8 +490,7 @@ describe Taskinator::Task do
           expect(args.first).to eq('taskinator.task.enqueued')
         end
 
-        # temporary subscription
-        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
+        TestInstrumenter.subscribe(instrumentation_block, /taskinator.task/) do
           subject.enqueue!
         end
       end
@@ -489,19 +515,24 @@ describe Taskinator::Task do
         instrumentation_block = SpecSupport::Block.new
 
         expect(instrumentation_block).to receive(:call) do |*args|
-          expect(args.first).to eq('taskinator.task.started')
+          expect(args.first).to eq('taskinator.task.processing')
         end
 
-        # temporary subscription
-        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
+        TestInstrumenter.subscribe(instrumentation_block, /taskinator.task/) do
           subject.start!
         end
       end
     end
 
     describe "#complete" do
+      it "notifies parent process" do
+        expect(process).to receive(:task_completed).with(subject)
+
+        subject.complete!
+      end
+
       it "is instrumented" do
-        allow(process).to receive(:task_completed)
+        allow(process).to receive(:task_completed).with(subject)
 
         instrumentation_block = SpecSupport::Block.new
 
@@ -509,8 +540,7 @@ describe Taskinator::Task do
           expect(args.first).to eq('taskinator.task.completed')
         end
 
-        # temporary subscription
-        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
+        TestInstrumenter.subscribe(instrumentation_block, /taskinator.task/) do
           subject.complete!
         end
       end
@@ -530,6 +560,8 @@ describe Taskinator::Task do
         expect(visitor).to receive(:visit_args).with(:options)
         expect(visitor).to receive(:visit_process).with(:sub_process)
         expect(visitor).to receive(:visit_attribute).with(:queue)
+        expect(visitor).to receive(:visit_attribute_time).with(:created_at)
+        expect(visitor).to receive(:visit_attribute_time).with(:updated_at)
 
         subject.accept(visitor)
       }

data/spec/taskinator/test_flows_spec.rb

@@ -6,7 +6,6 @@ describe TestFlows do
     TestFlows::Task,
     TestFlows::Job,
     TestFlows::SubProcess,
-    TestFlows::Sequential,
     TestFlows::Sequential
   ].each do |definition|
 
@@ -128,4 +127,270 @@ describe TestFlows do
     end
   end
 
+  describe "statuses" do
+    describe "task" do
+      before do
+        # override enqueue
+        allow_any_instance_of(Taskinator::Task::Step).to receive(:enqueue!) { |task|
+          # emulate the worker starting the task
+          task.start!
+        }
+      end
+
+      let(:task_count) { 2 }
+      let(:definition) { TestFlows::Task }
+      subject { definition.create_process(task_count) }
+
+      it "reports process and task state" do
+
+        instrumenter = TestInstrumenter.new do |name, payload|
+
+          case name
+          when 'taskinator.process.created', 'taskinator.process.saved'
+            expect(payload[:state]).to eq(:initial)
+          when 'taskinator.process.processing'
+            expect(payload[:state]).to eq(:processing)
+          when 'taskinator.task.processing'
+            expect(payload[:state]).to eq(:processing)
+          when 'taskinator.task.completed'
+            expect(payload[:state]).to eq(:completed)
+          when 'taskinator.process.completed'
+            expect(payload[:state]).to eq(:completed)
+          else
+            raise "Unknown event '#{name}'."
+          end
+
+        end
+
+        allow(Taskinator).to receive(:instrumenter).and_return(instrumenter)
+        expect(instrumenter).to receive(:instrument).at_least(task_count).times.and_call_original
+
+        expect(subject.current_state).to eq(:initial)
+
+        subject.start!
+      end
+
+    end
+
+    describe "job" do
+
+    end
+
+    describe "subprocess" do
+
+    end
+  end
+
+  describe "instrumentation" do
+    describe "task" do
+      before do
+        # override enqueue
+        allow_any_instance_of(Taskinator::Task::Step).to receive(:enqueue!) { |task|
+          # emulate the worker starting the task
+          task.start!
+        }
+      end
+
+      let(:task_count) { 10 }
+      let(:definition) { TestFlows::Task }
+      subject { definition.create_process(task_count) }
+
+      it "reports task completed" do
+        block = SpecSupport::Block.new
+        expect(block).to receive(:call).exactly(task_count).times
+
+        TestInstrumenter.subscribe(block, /taskinator.task.completed/) do
+          subject.start!
+        end
+      end
+
+      it "reports process completed" do
+        block = SpecSupport::Block.new
+        expect(block).to receive(:call).once
+
+        TestInstrumenter.subscribe(block, /taskinator.process.completed/) do
+          subject.start!
+        end
+      end
+
+      it "reports task percentage completed" do
+        invoke_count = 0
+
+        instrumenter = TestInstrumenter.new do |name, payload|
+          if name =~ /taskinator.task.processing/
+            expect(payload[:percentage_completed]).to eq( (invoke_count / task_count.to_f) * 100.0 )
+          elsif name =~ /taskinator.task.completed/
+            invoke_count += 1
+            expect(payload[:percentage_completed]).to eq( (invoke_count / task_count.to_f) * 100.0 )
+          end
+        end
+
+        allow(Taskinator).to receive(:instrumenter).and_return(instrumenter)
+        expect(instrumenter).to receive(:instrument).at_least(task_count).times.and_call_original
+
+        subject.start!
+      end
+
+      it "reports process percentage completed" do
+        instrumenter = TestInstrumenter.new do |name, payload|
+          if name =~ /taskinator.process.started/
+            expect(payload[:process_uuid]).to eq(subject.uuid)
+          elsif name =~ /taskinator.process.completed/
+            expect(payload[:percentage_completed]).to eq(100.0)
+          end
+        end
+
+        allow(Taskinator).to receive(:instrumenter).and_return(instrumenter)
+        expect(instrumenter).to receive(:instrument).at_least(task_count).times.and_call_original
+
+        subject.start!
+      end
+
+    end
+
+    describe "job" do
+      before do
+        # override enqueue
+        allow_any_instance_of(Taskinator::Task::Job).to receive(:enqueue!) { |task|
+          # emulate the worker starting the task
+          task.start!
+        }
+      end
+
+      let(:task_count) { 10 }
+      let(:definition) { TestFlows::Job }
+      subject { definition.create_process(task_count) }
+
+      it "reports task completed" do
+        block = SpecSupport::Block.new
+        expect(block).to receive(:call).exactly(task_count).times
+
+        TestInstrumenter.subscribe(block, /taskinator.task.completed/) do
+          subject.start!
+        end
+      end
+
+      it "reports process completed" do
+        block = SpecSupport::Block.new
+        expect(block).to receive(:call).once
+
+        TestInstrumenter.subscribe(block, /taskinator.process.completed/) do
+          subject.start!
+        end
+      end
+
+      it "reports task percentage completed" do
+        invoke_count = 0
+
+        instrumenter = TestInstrumenter.new do |name, payload|
+          if name =~ /taskinator.task.processing/
+            expect(payload[:percentage_completed]).to eq( (invoke_count / task_count.to_f) * 100.0 )
+          elsif name =~ /taskinator.task.completed/
+            invoke_count += 1
+            expect(payload[:percentage_completed]).to eq( (invoke_count / task_count.to_f) * 100.0 )
+          end
+        end
+
+        allow(Taskinator).to receive(:instrumenter).and_return(instrumenter)
+        expect(instrumenter).to receive(:instrument).at_least(task_count).times.and_call_original
+
+        subject.start!
+      end
+
+      it "reports process percentage completed" do
+        instrumenter = TestInstrumenter.new do |name, payload|
+          if name =~ /taskinator.process.started/
+            expect(payload[:process_uuid]).to eq(subject.uuid)
+          elsif name =~ /taskinator.process.completed/
+            expect(payload[:percentage_completed]).to eq(100.0)
+          end
+        end
+
+        allow(Taskinator).to receive(:instrumenter).and_return(instrumenter)
+        expect(instrumenter).to receive(:instrument).at_least(task_count).times.and_call_original
+
+        subject.start!
+      end
+
+    end
+
+    describe "sub process" do
+      before do
+        # override enqueue
+        allow_any_instance_of(Taskinator::Task::Step).to receive(:enqueue!) { |task|
+          # emulate the worker starting the task
+          task.start!
+        }
+
+        # override enqueue
+        allow_any_instance_of(Taskinator::Task::SubProcess).to receive(:enqueue!) { |task|
+          # emulate the worker starting the task
+          task.start!
+        }
+      end
+
+      let(:task_count) { 10 }
+      let(:definition) { TestFlows::SubProcess }
+      subject { definition.create_process(task_count) }
+
+      it "reports task completed" do
+        block = SpecSupport::Block.new
+
+        # NOTE: sub process counts for one task
+        expect(block).to receive(:call).exactly(task_count + 1).times
+
+        TestInstrumenter.subscribe(block, /taskinator.task.completed/) do
+          subject.start!
+        end
+      end
+
+      it "reports process completed" do
+        block = SpecSupport::Block.new
+        expect(block).to receive(:call).twice # includes sub process
+
+        TestInstrumenter.subscribe(block, /taskinator.process.completed/) do
+          subject.start!
+        end
+      end
+
+      it "reports task percentage completed" do
+        invoke_count = 0
+
+        instrumenter = TestInstrumenter.new do |name, payload|
+          if name =~ /taskinator.task.processing/
+            expect(payload[:percentage_completed]).to eq( (invoke_count / task_count.to_f) * 100.0 )
+          elsif name =~ /taskinator.task.completed/
+            unless payload.type >= Taskinator::Task::SubProcess
+              invoke_count += 1
+              expect(payload[:percentage_completed]).to eq( (invoke_count / task_count.to_f) * 100.0 )
+            end
+          end
+        end
+
+        allow(Taskinator).to receive(:instrumenter).and_return(instrumenter)
+        expect(instrumenter).to receive(:instrument).at_least(task_count).times.and_call_original
+
+        subject.start!
+      end
+
+      it "reports process percentage completed" do
+        instrumenter = TestInstrumenter.new do |name, payload|
+          if name =~ /taskinator.process.started/
+            expect(payload[:process_uuid]).to eq(subject.uuid)
+          elsif name =~ /taskinator.process.completed/
+            expect(payload[:percentage_completed]).to eq(100.0)
+          end
+        end
+
+        allow(Taskinator).to receive(:instrumenter).and_return(instrumenter)
+
+        # NOTE: sub process counts for one task
+        expect(instrumenter).to receive(:instrument).at_least(task_count + 1).times.and_call_original
+
+        subject.start!
+      end
+
+    end
+  end
+
 end

data/taskinator.gemspec

@@ -25,25 +25,4 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'redis-namespace'             , '>= 1.5.2'
   spec.add_dependency 'connection_pool'             , '>= 2.2.0'
   spec.add_dependency 'json'                        , '>= 1.8.2'
-
-  # spec.add_dependency 'workflow'                    , '>= 1.3.0'  # RubyGems not up to date as of 11 Nov 2014.
-
-  # queues
-  spec.add_development_dependency 'sidekiq'         , '>= 3.0.0'
-  spec.add_development_dependency 'rspec-sidekiq'   , '>= 2.0.0'
-
-  spec.add_development_dependency 'delayed_job'     , '>= 4.0.0'
-
-  spec.add_development_dependency 'resque'          , '>= 1.25.2'
-  spec.add_development_dependency 'resque_spec'     , '>= 0.16.0'
-
-  # other
-  spec.add_development_dependency 'bundler'         , '>= 1.6.0'
-  spec.add_development_dependency 'rake'            , '>= 10.3.0'
-  spec.add_development_dependency 'activesupport'   , '>= 4.0.0'
-  spec.add_development_dependency 'rspec'
-  spec.add_development_dependency 'coveralls'       , '>= 0.7.0'
-  spec.add_development_dependency 'pry'             , '>= 0.9.0'
-  spec.add_development_dependency 'pry-byebug'      , '>= 1.3.0'
-
 end