taskinator 0.0.18 → 0.2.0

data/spec/taskinator/process_spec.rb

@@ -74,20 +74,6 @@ describe Taskinator::Process do
           subject.enqueue!
           expect(subject.current_state.name).to eq(:enqueued)
         }
-
-        it "should not enqueue if there aren't any tasks" do
-          expect {
-            subject.enqueue!
-          }.to change { Taskinator.queue.processes.length }.by(0)
-        end
-
-        it "should enqueue if there are tasks" do
-          allow(subject).to receive(:tasks).and_return([Object.new])
-
-          expect {
-            subject.enqueue!
-          }.to change { Taskinator.queue.processes.length }.by(1)
-        end
       end
 
       describe "#start!" do
@@ -155,7 +141,6 @@ describe Taskinator::Process do
           subject.complete!
         }
         it {
-          expect(subject).to receive(:tasks_completed?) { true }
           subject.start!
           subject.complete!
           expect(subject.current_state.name).to eq(:completed)
@@ -216,10 +201,6 @@ describe Taskinator::Process do
       }
     end
 
-    describe "#reload" do
-      it { expect(subject.reload).to_not be }
-    end
-
     describe "#tasks_count" do
       it {
         expect(subject.tasks_count).to eq(0)
@@ -262,13 +243,31 @@ describe Taskinator::Process do
       end
     end
 
+    describe "#enqueue!" do
+      context "without tasks" do
+        it {
+          expect {
+            subject.enqueue!
+          }.to change { Taskinator.queue.tasks.length }.by(0)
+        }
+      end
+
+      it "delegates to the first task" do
+        task = double('task')
+        expect(task).to receive(:enqueue!)
+        allow(subject).to receive(:tasks).and_return([task])
+
+        subject.enqueue!
+      end
+    end
+
     describe "#start!" do
       it "executes the first task" do
         tasks.each {|t| subject.tasks << t }
         task1 = tasks[0]
 
         expect(subject.tasks).to receive(:first).and_call_original
-        expect(task1).to receive(:enqueue!)
+        expect(task1).to receive(:start!)
 
         subject.start!
       end
@@ -295,7 +294,6 @@ describe Taskinator::Process do
         tasks.each {|t| subject.tasks << t }
         task2 = tasks[1]
 
-        expect(subject).to receive(:can_complete?) { true }
         expect(subject).to receive(:complete!)
 
         subject.task_completed(task2)
@@ -380,11 +378,30 @@ describe Taskinator::Process do
       end
     end
 
+    describe "#enqueue!" do
+      context "without tasks" do
+        it {
+          expect {
+            subject.enqueue!
+          }.to change { Taskinator.queue.tasks.length }.by(0)
+        }
+      end
+
+      it "delegates to all the tasks" do
+        tasks.each {|t|
+          subject.tasks << t
+          expect(t).to receive(:enqueue!)
+        }
+
+        subject.enqueue!
+      end
+    end
+
     describe "#start!" do
       it "executes all tasks" do
         tasks.each {|t|
           subject.tasks << t
-          expect(t).to receive(:enqueue!)
+          expect(t).to receive(:start!)
         }
 
         subject.start!
@@ -400,7 +417,6 @@ describe Taskinator::Process do
       it "completes when tasks complete" do
         tasks.each {|t| subject.tasks << t }
 
-        expect(subject).to receive(:can_complete?) { true }
         expect(subject).to receive(:complete!)
 
         subject.task_completed(tasks.first)

data/spec/taskinator/queues/delayed_job_spec.rb

@@ -30,24 +30,6 @@ describe Taskinator::Queues::DelayedJobAdapter, :delayed_job do
     end
   end
 
-  describe "ProcessWorker" do
-    it "enqueues processes" do
-      expect {
-        subject.enqueue_process(double('process', :uuid => uuid, :queue => nil))
-      }.to change(Delayed::Job.queue, :size).by(1)
-    end
-
-    it "enqueues process to specified queue" do
-      subject.enqueue_process(double('process', :uuid => uuid, :queue => :other))
-      expect(Delayed::Job.contains?(adapter::ProcessWorker, uuid, :other)).to be
-    end
-
-    it "calls process worker" do
-      expect_any_instance_of(Taskinator::ProcessWorker).to receive(:perform)
-      adapter::ProcessWorker.new(uuid).perform
-    end
-  end
-
   describe "TaskWorker" do
     it "enqueues tasks" do
       expect {
@@ -92,7 +74,7 @@ describe Taskinator::Queues::DelayedJobAdapter, :delayed_job do
     let(:definition) { TestDefinition }
 
     it "performs invocation on job" do
-      args = {:a => 1}
+      args = [:foo, {:a => 1}]
       job = double('job')
       expect(job).to receive(:perform)
 

data/spec/taskinator/queues/resque_spec.rb

@@ -34,27 +34,6 @@ describe Taskinator::Queues::ResqueAdapter, :resque do
     end
   end
 
-  describe "ProcessWorker" do
-    it "enqueues processes" do
-      worker = adapter::ProcessWorker
-      subject.enqueue_process(double('process', :uuid => uuid, :queue => nil))
-
-      expect(worker).to have_queued(uuid)
-    end
-
-    it "enqueues process to specified queue" do
-      worker = adapter::ProcessWorker
-      subject.enqueue_process(double('process', :uuid => uuid, :queue => :other))
-
-      expect(worker).to have_queued(uuid).in(:other)
-    end
-
-    it "calls process worker" do
-      expect_any_instance_of(Taskinator::ProcessWorker).to receive(:perform)
-      adapter::ProcessWorker.perform(uuid)
-    end
-  end
-
   describe "TaskWorker" do
     it "enqueues tasks" do
       worker = adapter::TaskWorker
@@ -115,7 +94,7 @@ describe Taskinator::Queues::ResqueAdapter, :resque do
     let(:definition) { TestDefinition }
 
     it "performs invocation on job" do
-      args = {:a => 1}
+      args = [:foo, {:a => 1}]
       job_class = double('job_class', :methods => [:perform])
       expect(job_class).to receive(:perform).with(*args)
 

data/spec/taskinator/queues/sidekiq_spec.rb

@@ -33,25 +33,6 @@ describe Taskinator::Queues::SidekiqAdapter, :sidekiq do
     end
   end
 
-  describe "ProcessWorker" do
-    it "enqueues processes" do
-      worker = adapter::ProcessWorker
-      process = double('process', :uuid => uuid, :queue => nil)
-      subject.enqueue_process(process)
-      expect(worker).to have_enqueued_job(process.uuid)
-    end
-
-    it "enqueues process to specified queue" do
-      subject.enqueue_process(double('process', :uuid => uuid, :queue => :other))
-      expect(adapter::ProcessWorker).to be_processed_in_x(:other)
-    end
-
-    it "calls process worker" do
-      expect_any_instance_of(Taskinator::ProcessWorker).to receive(:perform)
-      adapter::ProcessWorker.new.perform(uuid)
-    end
-  end
-
   describe "TaskWorker" do
     it "enqueues tasks" do
       worker = adapter::TaskWorker
@@ -106,7 +87,7 @@ describe Taskinator::Queues::SidekiqAdapter, :sidekiq do
     let(:definition) { TestDefinition }
 
     it "performs invocation on job" do
-      args = {:a => 1}
+      args = [:foo, {:a => 1}]
       job = double('job')
       expect(job).to receive(:perform).with(*args)
 

data/spec/taskinator/task_spec.rb

@@ -7,6 +7,7 @@ describe Taskinator::Task do
   describe "Base" do
 
     let(:process) { Class.new(Taskinator::Process).new(definition) }
+
     subject { Class.new(Taskinator::Task).new(process) }
 
     describe "#initialize" do
@@ -49,14 +50,6 @@ describe Taskinator::Task do
       it { expect(subject.current_state.name).to eq(:initial) }
     end
 
-    describe "#can_complete_task?" do
-      it {
-        expect {
-          subject.can_complete_task?
-        }.to raise_error(NotImplementedError)
-      }
-    end
-
     describe "workflow" do
       describe "#enqueue!" do
         it { expect(subject).to respond_to(:enqueue!) }
@@ -68,11 +61,6 @@ describe Taskinator::Task do
           subject.enqueue!
           expect(subject.current_state.name).to eq(:enqueued)
         }
-        it {
-          expect {
-            subject.enqueue!
-          }.to change { Taskinator.queue.tasks.length }.by(1)
-        }
       end
 
       describe "#start!" do
@@ -90,9 +78,7 @@ describe Taskinator::Task do
       describe "#complete!" do
         it { expect(subject).to respond_to(:complete!) }
         it {
-          expect(subject).to receive(:can_complete_task?) { true }
           expect(subject).to receive(:complete)
-          expect(process).to receive(:task_completed).with(subject)
           subject.start!
           subject.complete!
           expect(subject.current_state.name).to eq(:completed)
@@ -158,10 +144,6 @@ describe Taskinator::Task do
       }
     end
 
-    describe "#reload" do
-      it { expect(subject.reload).to_not be }
-    end
-
     describe "#tasks_count" do
       it {
         expect(subject.tasks_count).to eq(0)
@@ -172,15 +154,15 @@ describe Taskinator::Task do
   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, :method, {:a => 1, :b => 2}) }
+      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, :method, {:a => 1, :b => 2}) }
+    subject { Taskinator::Task.define_step_task(process, :do_task, {:a => 1, :b => 2}) }
 
     describe ".define_step_task" do
       it "sets the queue to use" do
-        task = Taskinator::Task.define_step_task(process, :method, {:a => 1, :b => 2}, :queue => :foo)
+        task = Taskinator::Task.define_step_task(process, :do_task, {:a => 1, :b => 2}, :queue => :foo)
         expect(task.queue).to eq(:foo)
       end
     end
@@ -188,18 +170,47 @@ describe Taskinator::Task do
     describe "#executor" do
       it { expect(subject.executor).to_not be_nil }
       it { expect(subject.executor).to be_a(definition) }
-    end
-
-    describe "#start!" do
-      it "invokes executor" do
-        expect(subject.executor).to receive(subject.method).with(*subject.args)
-        subject.start!
-      end
 
       it "handles failure" do
         error = StandardError.new
         allow(subject.executor).to receive(subject.method).with(*subject.args).and_raise(error)
         expect(subject).to receive(:fail!).with(error)
+        expect {
+          subject.start!
+        }.to raise_error(error)
+      end
+    end
+
+    describe "#enqueue!" do
+      it {
+        expect {
+          subject.enqueue!
+        }.to change { Taskinator.queue.tasks.length }.by(1)
+      }
+
+      it "is instrumented" do
+        allow(subject.executor).to receive(subject.method).with(*subject.args)
+
+        instrumentation_block = SpecSupport::Block.new
+
+        expect(instrumentation_block).to receive(:call) do |*args|
+          expect(args.first).to eq('taskinator.task.enqueued')
+        end
+
+        # temporary subscription
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
+          subject.enqueue!
+        end
+      end
+    end
+
+    describe "#start!" do
+      before do
+        expect(process).to receive(:task_completed).with(subject)
+      end
+
+      it "invokes executor" do
+        expect(subject.executor).to receive(subject.method).with(*subject.args)
         subject.start!
       end
 
@@ -232,25 +243,39 @@ describe Taskinator::Task do
       end
 
       it "is instrumented" do
-        allow(subject.executor).to receive(subject.method)
-
         instrumentation_block = SpecSupport::Block.new
-        expect(instrumentation_block).to receive(:call)
+
+        expect(instrumentation_block).to receive(:call) do |*args|
+          expect(args.first).to eq('taskinator.task.started')
+        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, /execute_step_task/) do
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
           subject.start!
         end
       end
     end
 
-    describe "#can_complete_task?" do
-      it { expect(subject.can_complete_task?).to_not be }
-      it {
-        allow(subject.executor).to receive(subject.method).with(*subject.args)
-        subject.start!
-        expect(subject.can_complete_task?).to be
-      }
+    describe "#complete" do
+      it "is instrumented" do
+        allow(process).to receive(:task_completed)
+
+        instrumentation_block = SpecSupport::Block.new
+
+        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
+          subject.complete!
+        end
+      end
     end
 
     describe "#accept" do
@@ -307,9 +332,26 @@ describe Taskinator::Task do
           subject.enqueue!
         }.to change { Taskinator.queue.jobs.length }.by(1)
       }
+
+      it "is instrumented" do
+        instrumentation_block = SpecSupport::Block.new
+
+        expect(instrumentation_block).to receive(:call) do |*args|
+          expect(args.first).to eq('taskinator.task.enqueued')
+        end
+
+        # temporary subscription
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
+          subject.enqueue!
+        end
+      end
     end
 
     describe "#perform" do
+      before do
+        expect(process).to receive(:task_completed).with(subject)
+      end
+
       it {
         block = SpecSupport::Block.new
         expect(block).to receive(:call).with(TestJob, {:a => 1, :b => 2})
@@ -319,18 +361,43 @@ describe Taskinator::Task do
 
       it "is instrumented" do
         block = SpecSupport::Block.new
-        allow(block).to receive(:call)
+        allow(block).to receive(:call).with(TestJob, {:a => 1, :b => 2})
 
         instrumentation_block = SpecSupport::Block.new
-        expect(instrumentation_block).to receive(:call)
+
+        expect(instrumentation_block).to receive(:call) do |*args|
+          expect(args.first).to eq('taskinator.task.started')
+        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, /execute_job_task/) do
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
           subject.perform(&block)
         end
       end
     end
 
+    describe "#complete" do
+      it "is instrumented" do
+        allow(process).to receive(:task_completed)
+
+        instrumentation_block = SpecSupport::Block.new
+
+        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
+          subject.complete!
+        end
+      end
+    end
+
     describe "#accept" do
       it {
         expect(subject).to receive(:accept)
@@ -375,6 +442,34 @@ describe Taskinator::Task do
       end
     end
 
+    describe "#enqueue!" do
+      context "without tasks" do
+        it {
+          expect {
+            subject.enqueue!
+          }.to change { Taskinator.queue.tasks.length }.by(0)
+        }
+      end
+
+      it "delegates to sub process" do
+        expect(sub_process).to receive(:enqueue!)
+        subject.enqueue!
+      end
+
+      it "is instrumented" do
+        instrumentation_block = SpecSupport::Block.new
+
+        expect(instrumentation_block).to receive(:call) do |*args|
+          expect(args.first).to eq('taskinator.task.enqueued')
+        end
+
+        # temporary subscription
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
+          subject.enqueue!
+        end
+      end
+    end
+
     describe "#start!" do
       it "delegates to sub process" do
         expect(sub_process).to receive(:start)
@@ -385,26 +480,39 @@ describe Taskinator::Task do
         error = StandardError.new
         allow(sub_process).to receive(:start!).and_raise(error)
         expect(subject).to receive(:fail!).with(error)
-        subject.start!
+        expect {
+          subject.start!
+        }.to raise_error(error)
       end
 
       it "is instrumented" do
-        allow(sub_process).to receive(:start)
-
         instrumentation_block = SpecSupport::Block.new
-        expect(instrumentation_block).to receive(:call)
+
+        expect(instrumentation_block).to receive(:call) do |*args|
+          expect(args.first).to eq('taskinator.task.started')
+        end
 
         # temporary subscription
-        ActiveSupport::Notifications.subscribed(instrumentation_block, /execute_subprocess/) do
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.task/) do
           subject.start!
         end
       end
     end
 
-    describe "#can_complete_task?" do
-      it "delegates to sub process" do
-        expect(sub_process).to receive(:completed?)
-        subject.can_complete_task?
+    describe "#complete" do
+      it "is instrumented" do
+        allow(process).to receive(:task_completed)
+
+        instrumentation_block = SpecSupport::Block.new
+
+        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
+          subject.complete!
+        end
       end
     end
 

data/spec/taskinator/task_worker_spec.rb

@@ -24,22 +24,6 @@ describe Taskinator::TaskWorker do
     subject.perform
   end
 
-  it "should complete the task if can_complete? is true" do
-    task = mock_task(false, false, true)
-    allow(Taskinator::Task).to receive(:fetch).with(uuid) { task }
-    allow(task).to receive(:start!)
-    expect(task).to receive(:complete!)
-    subject.perform
-  end
-
-  it "should not complete the task if can_complete? is false" do
-    task = mock_task
-    allow(Taskinator::Task).to receive(:fetch).with(uuid) { task }
-    allow(task).to receive(:start!)
-    expect(task).to_not receive(:complete!)
-    subject.perform
-  end
-
   it "should not start if paused" do
     task = mock_task(true, false)
     allow(Taskinator::Task).to receive(:fetch).with(uuid) { task }
@@ -58,7 +42,6 @@ describe Taskinator::TaskWorker do
     task = mock_task
     allow(Taskinator::Task).to receive(:fetch).with(uuid) { task }
     allow(task).to receive(:start!) { raise StandardError }
-    expect(task).to receive(:fail!).with(StandardError)
     expect {
       subject.perform
     }.to raise_error(StandardError)

data/spec/taskinator/test_flows_spec.rb

@@ -85,4 +85,47 @@ describe TestFlows do
       end
     end
   end
+
+  describe "scenarios" do
+
+    before do
+      # use the "synchronous" queue
+      Taskinator.queue_adapter = :test_queue_worker
+    end
+
+    context "empty subprocesses" do
+
+      context "sequential" do
+        let(:definition) { TestFlows::EmptySequentialProcessTest }
+        subject { definition.create_process }
+
+        it "invokes each task" do
+          # this doesn't work...
+          # expect_any_instance_of(Taskinator::Executor).to receive(:do_task_x).exactly(3).times
+          # subject.start!
+
+          expect {
+            subject.enqueue!
+          }.to change { Taskinator.queue.tasks.length }.by(3)
+        end
+      end
+
+      context "concurrent" do
+        let(:definition) { TestFlows::EmptyConcurrentProcessTest }
+        subject { definition.create_process }
+
+        it "invokes each task" do
+          # this doesn't work...
+          # expect_any_instance_of(Taskinator::Executor).to receive(:do_task_x).exactly(3).times
+          # subject.start!
+
+          expect {
+            subject.enqueue!
+          }.to change { Taskinator.queue.tasks.length }.by(3)
+        end
+      end
+
+    end
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: taskinator
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.2.0
 platform: ruby
 authors:
 - Chris Stefano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-14 00:00:00.000000000 Z
+date: 2015-07-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -268,7 +268,6 @@ files:
 - lib/taskinator/logger.rb
 - lib/taskinator/persistence.rb
 - lib/taskinator/process.rb
-- lib/taskinator/process_worker.rb
 - lib/taskinator/queues.rb
 - lib/taskinator/queues/delayed_job.rb
 - lib/taskinator/queues/resque.rb
@@ -305,7 +304,6 @@ files:
 - spec/taskinator/job_worker_spec.rb
 - spec/taskinator/persistence_spec.rb
 - spec/taskinator/process_spec.rb
-- spec/taskinator/process_worker_spec.rb
 - spec/taskinator/queues/delayed_job_spec.rb
 - spec/taskinator/queues/resque_spec.rb
 - spec/taskinator/queues/sidekiq_spec.rb
@@ -368,7 +366,6 @@ test_files:
 - spec/taskinator/job_worker_spec.rb
 - spec/taskinator/persistence_spec.rb
 - spec/taskinator/process_spec.rb
-- spec/taskinator/process_worker_spec.rb
 - spec/taskinator/queues/delayed_job_spec.rb
 - spec/taskinator/queues/resque_spec.rb
 - spec/taskinator/queues/sidekiq_spec.rb

data/lib/taskinator/process_worker.rb

@@ -1,21 +0,0 @@
-module Taskinator
-  class ProcessWorker
-    attr_reader :uuid
-
-    def initialize(uuid)
-      @uuid = uuid
-    end
-
-    def perform
-      process = Taskinator::Process.fetch(@uuid)
-      return if process.paused? || process.cancelled?
-      begin
-        process.start!
-      rescue => e
-        Taskinator.logger.error(e)
-        process.fail!(e)
-        raise e
-      end
-    end
-  end
-end