taskinator 0.0.18 → 0.2.0

data/spec/support/test_flows.rb

@@ -10,13 +10,22 @@ module TestFlows
 
   module Support
 
-    def iterator(task_count)
+    def iterator(task_count, *args)
       task_count.times do |i|
-        yield i
+        yield i, *args
       end
     end
 
     def do_task(*args)
+      Taskinator.logger.info(">>> Executing task do_task [#{uuid}]...")
+    end
+
+    # just create lots of these, so it's easy to see which task
+    # corresponds with each method when debugging specs
+    20.times do |i|
+      define_method "task_#{i}" do |*args|
+        Taskinator.logger.info(">>> Executing task #{__method__} [#{uuid}]...")
+      end
     end
 
   end
@@ -27,7 +36,7 @@ module TestFlows
 
     define_process :task_count do
       for_each :iterator do
-        task :do_task
+        task :do_task, :queue => :foo
       end
     end
 
@@ -83,4 +92,46 @@ module TestFlows
 
   end
 
+  module EmptySequentialProcessTest
+    extend Taskinator::Definition
+    include Support
+
+    define_process do
+
+      task :task_0
+
+      sequential do
+        # NB: empty!
+      end
+
+      sequential do
+        task :task_1
+      end
+
+      task :task_2
+
+    end
+  end
+
+  module EmptyConcurrentProcessTest
+    extend Taskinator::Definition
+    include Support
+
+    define_process do
+
+      task :task_0
+
+      concurrent do
+        # NB: empty!
+      end
+
+      concurrent do
+        task :task_1
+      end
+
+      task :task_2
+
+    end
+  end
+
 end

data/spec/support/test_queue.rb

@@ -5,10 +5,13 @@ module Taskinator
       TestQueueAdapter.new
     end
 
+    def self.create_test_queue_worker_adapter(config={})
+      QueueWorkerAdapter.new
+    end
+
     class TestQueueAdapter
 
       attr_reader :creates
-      attr_reader :processes
       attr_reader :tasks
       attr_reader :jobs
 
@@ -18,7 +21,6 @@ module Taskinator
 
       def clear
         @creates = []
-        @processes = []
         @tasks = []
         @jobs = []
       end
@@ -27,10 +29,6 @@ module Taskinator
         @creates << [definition, uuid, args]
       end
 
-      def enqueue_process(process)
-        @processes << process
-      end
-
       def enqueue_task(task)
         @tasks << task
       end
@@ -39,6 +37,43 @@ module Taskinator
         @jobs << job
       end
 
+      def empty?
+        @creates.empty? && @tasks.empty? && @jobs.empty?
+      end
+
     end
+
+    #
+    # this is a "synchronous" implementation for use in testing
+    #
+    class QueueWorkerAdapter < TestQueueAdapter
+
+      def enqueue_create_process(definition, uuid, args)
+        super
+        invoke do
+          Taskinator::CreateProcessWorker.new(definition.name, uuid, args).perform
+        end
+      end
+
+      def enqueue_task(task)
+        super
+        invoke do
+          Taskinator::TaskWorker.new(task.uuid).perform
+        end
+      end
+
+      def enqueue_job(job)
+        super
+        invoke do
+          Taskinator::JobWorker.new(job.uuid).perform
+        end
+      end
+
+      def invoke(&block)
+        block.call
+      end
+
+    end
+
   end
 end

data/spec/taskinator/create_process_worker_spec.rb

@@ -13,12 +13,23 @@ describe Taskinator::CreateProcessWorker do
       expect(subject.definition).to eq(definition)
     }
 
+    it {
+      Taskinator::CreateProcessWorker.new(definition.name, uuid, Taskinator::Persistence.serialize(:foo => :bar))
+      expect(subject.definition).to eq(definition)
+    }
+
     it {
       MockDefinition.const_set(definition.name, definition)
       Taskinator::CreateProcessWorker.new("MockDefinition::#{definition.name}", uuid, Taskinator::Persistence.serialize(:foo => :bar))
       expect(subject.definition).to eq(definition)
     }
 
+    it {
+      expect {
+        Taskinator::CreateProcessWorker.new("NonExistent", uuid, Taskinator::Persistence.serialize(:foo => :bar))
+      }.to raise_error(NameError)
+    }
+
     it {
       expect(subject.uuid).to eq(uuid)
     }
@@ -30,7 +41,7 @@ describe Taskinator::CreateProcessWorker do
 
   describe "#perform" do
     it "should create the process" do
-      expect(definition).to receive(:_create_process_).with(*args, :uuid => uuid).and_return(double('process', :enqueue! => nil))
+      expect(definition).to receive(:_create_process_).with(false, *args, :uuid => uuid).and_return(double('process', :enqueue! => nil))
       subject.perform
     end
 
@@ -39,6 +50,4 @@ describe Taskinator::CreateProcessWorker do
       subject.perform
     end
   end
-
-
 end

data/spec/taskinator/definition/builder_spec.rb

@@ -15,7 +15,9 @@ describe Taskinator::Definition::Builder do
     Class.new(Taskinator::Process).new(definition)
   }
 
-  let(:args) { [:arg1, :arg2, {:option => 1, :another => false}] }
+  let(:args) { [:arg1, :arg2] }
+  let(:builder_options) { {:option1 => 1, :another => false} }
+  let(:options) { { :bar => :baz } }
 
   let(:block) { SpecSupport::Block.new }
 
@@ -24,19 +26,19 @@ describe Taskinator::Definition::Builder do
     Proc.new {|*args| the_block.call }
   }
 
-  subject { Taskinator::Definition::Builder.new(process, definition, *args) }
+  subject { Taskinator::Definition::Builder.new(process, definition, *[*args, builder_options]) }
 
   it "assign attributes" do
     expect(subject.process).to eq(process)
     expect(subject.definition).to eq(definition)
     expect(subject.args).to eq(args)
-    expect(subject.options).to eq({:option => 1, :another => false})
+    expect(subject.builder_options).to eq(builder_options)
   end
 
   describe "#option?" do
-    it "invokes supplied block for 'option' option" do
+    it "invokes supplied block for 'option1' option" do
       expect(block).to receive(:call)
-      subject.option?(:option, &define_block)
+      subject.option?(:option1, &define_block)
     end
 
     it "does not invoke supplied block for 'another' option" do
@@ -67,6 +69,12 @@ describe Taskinator::Definition::Builder do
         subject.sequential
       }.to raise_error(ArgumentError)
     end
+
+    it "includes options" do
+      allow(block).to receive(:call)
+      expect(Taskinator::Process).to receive(:define_sequential_process_for).with(definition, options).and_call_original
+      subject.sequential(options, &define_block)
+    end
   end
 
   describe "#concurrent" do
@@ -86,6 +94,12 @@ describe Taskinator::Definition::Builder do
         subject.concurrent
       }.to raise_error(ArgumentError)
     end
+
+    it "includes options" do
+      allow(block).to receive(:call)
+      expect(Taskinator::Process).to receive(:define_concurrent_process_for).with(definition, Taskinator::CompleteOn::First, options).and_call_original
+      subject.concurrent(Taskinator::CompleteOn::First, options, &define_block)
+    end
   end
 
   describe "#for_each" do
@@ -146,7 +160,7 @@ describe Taskinator::Definition::Builder do
 
   describe "#task" do
     it "creates a task" do
-      expect(Taskinator::Task).to receive(:define_step_task).with(process, :task_method, args, {})
+      expect(Taskinator::Task).to receive(:define_step_task).with(process, :task_method, args, builder_options)
       subject.task(:task_method)
     end
 
@@ -161,12 +175,17 @@ describe Taskinator::Definition::Builder do
         subject.task(:undefined)
       }.to raise_error(NoMethodError)
     end
+
+    it "includes options" do
+      expect(Taskinator::Task).to receive(:define_step_task).with(process, :task_method, args, builder_options.merge(options))
+      subject.task(:task_method, options)
+    end
   end
 
   describe "#job" do
     it "creates a job" do
       job = double('job', :perform => true)
-      expect(Taskinator::Task).to receive(:define_job_task).with(process, job, args, {})
+      expect(Taskinator::Task).to receive(:define_job_task).with(process, job, args, builder_options)
       subject.job(job)
     end
 
@@ -182,6 +201,12 @@ describe Taskinator::Definition::Builder do
         subject.job(double('job', :methods => [], :instance_methods => []))
       }.to raise_error(ArgumentError)
     end
+
+    it "includes options" do
+      job = double('job', :perform => true)
+      expect(Taskinator::Task).to receive(:define_job_task).with(process, job, args, builder_options.merge(options))
+      subject.job(job, options)
+    end
   end
 
   describe "#sub_process" do
@@ -195,16 +220,21 @@ describe Taskinator::Definition::Builder do
     end
 
     it "creates a sub process" do
-      expect(sub_definition).to receive(:create_sub_process).with(*args).and_call_original
+      expect(sub_definition).to receive(:create_sub_process).with(*args, builder_options).and_call_original
       subject.sub_process(sub_definition)
     end
 
     it "creates a sub process task" do
       sub_process = sub_definition.create_process(:argX, :argY, :argZ)
       allow(sub_definition).to receive(:create_sub_process) { sub_process }
-      expect(Taskinator::Task).to receive(:define_sub_process_task).with(process, sub_process, {})
+      expect(Taskinator::Task).to receive(:define_sub_process_task).with(process, sub_process, builder_options)
       subject.sub_process(sub_definition)
     end
+
+    it "includes options" do
+      expect(sub_definition).to receive(:create_sub_process).with(*args, builder_options.merge(options)).and_call_original
+      subject.sub_process(sub_definition, options)
+    end
   end
 
 end

data/spec/taskinator/definition_spec.rb

@@ -106,6 +106,17 @@ describe Taskinator::Definition do
       expect(subject.create_process).to be_a(Taskinator::Process)
     end
 
+    it "receives options" do
+      block = SpecSupport::Block.new
+      allow(block).to receive(:to_proc) {
+        Proc.new {|*args| }
+      }
+      subject.define_process(&block)
+
+      process = subject.create_process(:foo => :bar)
+      expect(process.options).to eq(:foo => :bar)
+    end
+
     it "invokes the given block in the context of a ProcessBuilder" do
       block = SpecSupport::Block.new
       expect(block).to receive(:call)
@@ -133,20 +144,24 @@ describe Taskinator::Definition do
 
       it "for create process" do
         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.process.created')
+        end
 
         # temporary subscription
-        ActiveSupport::Notifications.subscribed(instrumentation_block, /create_process/) do
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.process.created/) do
           subject.create_process :foo
         end
       end
 
       it "for save process" do
         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.process.saved')
+        end
 
         # temporary subscription
-        ActiveSupport::Notifications.subscribed(instrumentation_block, /save_process/) do
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /taskinator.process.saved/) do
           subject.create_process :foo
         end
       end
@@ -170,7 +185,6 @@ describe Taskinator::Definition do
       process = subject.create_process_remotely
 
       expect(process).to_not be_nil
-      expect(process.uuid).to_not be_nil
     end
 
     it "enqueues" do
@@ -184,28 +198,6 @@ describe Taskinator::Definition do
 
       subject.create_process_remotely
     end
-
-    describe "reloading" do
-      it "returns false if not persisted yet" do
-        block = SpecSupport::Block.new
-        allow(block).to receive(:to_proc) {
-          Proc.new {|*args| }
-        }
-        subject.define_process(&block)
-        process = subject.create_process_remotely
-
-        expect(process.reload).to eq(false)
-      end
-
-      it "returns true if persisted" do
-        definition = MockDefinition.create
-        process = definition.create_process_remotely(:foo)
-        definition._create_process_(:foo, :uuid => process.uuid).save
-
-        expect(process.reload).to eq(true)
-      end
-    end
-
   end
 
   describe "#queue" do

data/spec/taskinator/executor_spec.rb

@@ -8,7 +8,25 @@ describe Taskinator::Executor do
     end
   end
 
-  subject { Taskinator::Executor.new(definition) }
+  let(:task) { double('task') }
+  subject { Taskinator::Executor.new(definition, task) }
+
+  describe "helpers" do
+    it "#process_uuid" do
+      expect(task).to receive(:process_uuid)
+      subject.process_uuid
+    end
+
+    it "#uuid" do
+      expect(task).to receive(:uuid)
+      subject.uuid
+    end
+
+    it "#options" do
+      expect(task).to receive(:options)
+      subject.options
+    end
+  end
 
   it "should mixin definition" do
     expect(subject).to be_a(definition)

data/spec/taskinator/job_worker_spec.rb

@@ -33,16 +33,6 @@ describe Taskinator::JobWorker do
     allow(Taskinator::Task).to receive(:fetch).with(uuid) { job }
     allow(job).to receive(:start!)
     expect(job).to receive(:perform)
-    allow(job).to receive(:complete!)
-    subject.perform
-  end
-
-  it "should complete the job" do
-    job = mock_job
-    allow(Taskinator::Task).to receive(:fetch).with(uuid) { job }
-    allow(job).to receive(:start!)
-    allow(job).to receive(:perform)
-    expect(job).to receive(:complete!)
     subject.perform
   end
 
@@ -64,7 +54,6 @@ describe Taskinator::JobWorker do
     job = mock_job
     allow(Taskinator::Task).to receive(:fetch).with(uuid) { job }
     allow(job).to receive(:start!) { raise StandardError }
-    expect(job).to receive(:fail!).with(StandardError)
     expect {
       subject.perform
     }.to raise_error(StandardError)

data/spec/taskinator/persistence_spec.rb

@@ -224,14 +224,34 @@ describe Taskinator::Persistence, :redis => true do
       klass.new
     }
 
+    describe "#save" do
+      pending __FILE__
+    end
+
     describe "#key" do
       it {
-        expect(subject.key).to match(/#{subject.uuid}/)
+        expect(subject.key).to match(/taskinator:base_key:#{subject.uuid}/)
       }
     end
 
-    describe "#save" do
-      pending __FILE__
+    describe "#process_uuid" do
+      it {
+        Taskinator.redis do |conn|
+          conn.hset(subject.key, :process_uuid, subject.uuid)
+        end
+
+        expect(subject.process_uuid).to match(/#{subject.uuid}/)
+      }
+    end
+
+    describe "#process_key" do
+      it {
+        Taskinator.redis do |conn|
+          conn.hset(subject.key, :process_uuid, subject.uuid)
+        end
+
+        expect(subject.process_key).to match(/taskinator:process:#{subject.uuid}/)
+      }
     end
 
     describe "#load_workflow_state" do
@@ -256,11 +276,13 @@ describe Taskinator::Persistence, :redis => true do
           subject.fail(e)
         end
 
-        Taskinator.redis do |conn|
-          expect(conn.hget(subject.key, :error_type)).to eq('StandardError')
-          expect(conn.hget(subject.key, :error_message)).to eq('a error')
-          expect(conn.hget(subject.key, :error_backtrace)).to_not be_empty
+        type, message, backtrace = Taskinator.redis do |conn|
+          conn.hmget(subject.key, :error_type, :error_message, :error_backtrace)
         end
+
+        expect(type).to eq('StandardError')
+        expect(message).to eq('a error')
+        expect(backtrace).to_not be_empty
       end
     end
 
@@ -278,5 +300,98 @@ describe Taskinator::Persistence, :redis => true do
         expect(subject.error).to eq([error.class.name, error.message, error.backtrace])
       end
     end
+
+    describe "#tasks_count" do
+      it {
+        Taskinator.redis do |conn|
+          conn.hset(subject.process_key, :tasks_count, 99)
+        end
+
+        expect(subject.tasks_count).to eq(99)
+      }
+    end
+
+    %w(
+      failed
+      cancelled
+      completed
+    ).each do |status|
+
+      describe "#count_#{status}" do
+        it {
+          Taskinator.redis do |conn|
+            conn.hset(subject.process_key, status, 99)
+          end
+
+          expect(subject.send(:"count_#{status}")).to eq(99)
+        }
+      end
+
+      describe "#incr_#{status}" do
+        it {
+          Taskinator.redis do |conn|
+            conn.hset(subject.process_key, status, 99)
+          end
+
+          subject.send(:"incr_#{status}")
+
+          expect(subject.send(:"count_#{status}")).to eq(100)
+        }
+      end
+
+      describe "#percentage_#{status}" do
+        it {
+          Taskinator.redis do |conn|
+            conn.hmset(
+              subject.process_key,
+              [:tasks_count, 100],
+              [status, 1]
+            )
+          end
+
+          expect(subject.send(:"percentage_#{status}")).to eq(1.0)
+        }
+      end
+
+    end
+
+    describe "#process_options" do
+      it {
+        Taskinator.redis do |conn|
+          conn.hset(subject.process_key, :options, YAML.dump({:foo => :bar}))
+        end
+
+        expect(subject.process_options).to eq(:foo => :bar)
+      }
+    end
+
+    describe "#instrumentation_payload" do
+      it {
+        Taskinator.redis do |conn|
+          conn.hset(subject.key, :process_uuid, subject.uuid)
+          conn.hmset(
+            subject.process_key,
+            [:options, YAML.dump({:foo => :bar})],
+            [:tasks_count, 100],
+            [:completed, 3],
+            [:cancelled, 2],
+            [:failed, 1]
+          )
+        end
+
+        expect(subject.instrumentation_payload(:baz => :qux)).to eq({
+          :type                  => subject.class.name,
+          :process_uuid          => subject.uuid,
+          :process_options       => {:foo => :bar},
+          :uuid                  => subject.uuid,
+          :percentage_failed     => 1.0,
+          :percentage_cancelled  => 2.0,
+          :percentage_completed  => 3.0,
+          :tasks_count           => 100,
+          :baz                   => :qux
+        })
+      }
+
+    end
   end
 end