taskinator 0.0.15 → 0.0.16

data/spec/taskinator/persistence_spec.rb

@@ -2,21 +2,11 @@ require 'spec_helper'
 
 describe Taskinator::Persistence, :redis => true do
 
-  module TestDefinition
-    extend Taskinator::Definition
-  end
-
   let(:definition) { TestDefinition }
 
-  class TestProcess < Taskinator::Process
-  end
-
-  class TestTask < Taskinator::Task
-  end
-
   describe "class methods" do
     subject {
-      Class.new() do
+      Class.new do
         include Taskinator::Persistence
       end
     }
@@ -99,7 +89,7 @@ describe Taskinator::Persistence, :redis => true do
 
   describe "instance methods" do
     subject {
-      klass = Class.new() do
+      klass = Class.new do
         include Taskinator::Persistence
 
         def self.base_key
@@ -112,7 +102,7 @@ describe Taskinator::Persistence, :redis => true do
           @uuid = SecureRandom.uuid
         end
       end
-      klass.new()
+      klass.new
     }
 
     describe "#key" do
@@ -122,7 +112,7 @@ describe Taskinator::Persistence, :redis => true do
     end
 
     describe "#save" do
-      pending
+      pending __FILE__
     end
 
     describe "#load_workflow_state" do
@@ -141,14 +131,16 @@ describe Taskinator::Persistence, :redis => true do
     describe "#fail" do
       it "persists error information" do
         begin
-          raise StandardError, 'a error'
-        rescue Exception => e
+          # raise this error in a block, so there is a backtrace!
+          raise StandardError.new('a error')
+        rescue => e
           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
         end
       end
     end
@@ -157,10 +149,11 @@ describe Taskinator::Persistence, :redis => true do
       it "retrieves error information" do
         error = nil
         begin
-          raise StandardError, 'a error'
-        rescue Exception => e
+          # raise this error in a block, so there is a backtrace!
+          raise StandardError.new('a error')
+        rescue => e
           error = e
-          subject.fail(e)
+          subject.fail(error)
         end
 
         expect(subject.error).to eq([error.class.name, error.message, error.backtrace])

data/spec/taskinator/process_spec.rb

@@ -2,11 +2,7 @@ require 'spec_helper'
 
 describe Taskinator::Process do
 
-  let(:definition) do
-    Module.new() do
-      extend Taskinator::Definition
-    end
-  end
+  let(:definition) { TestDefinition }
 
   describe "Base" do
 
@@ -39,6 +35,17 @@ describe Taskinator::Process do
       it { expect(subject.to_s).to match(/#{subject.uuid}/) }
     end
 
+    describe "#queue" do
+      it {
+        expect(subject.queue).to be_nil
+      }
+
+      it {
+        process = Class.new(Taskinator::Process).new(definition, :queue => :foo)
+        expect(process.queue).to eq(:foo)
+      }
+    end
+
     describe "#current_state" do
       it { expect(subject).to be_a(::Workflow)  }
       it { expect(subject.current_state).to_not be_nil }
@@ -189,10 +196,15 @@ describe Taskinator::Process do
         expect(visitor).to receive(:visit_args).with(:options)
         expect(visitor).to receive(:visit_task_reference).with(:parent)
         expect(visitor).to receive(:visit_tasks)
+        expect(visitor).to receive(:visit_attribute).with(:queue)
 
         subject.accept(visitor)
       }
     end
+
+    describe "#reload" do
+      it { expect(subject.reload).to_not be }
+    end
   end
 
   describe Taskinator::Process::Sequential do
@@ -222,6 +234,11 @@ describe Taskinator::Process do
           Taskinator::Process.define_sequential_process_for(Object)
         }.to raise_error(ArgumentError)
       end
+
+      it "sets the queue to use" do
+        process = Taskinator::Process.define_sequential_process_for(definition, :queue => :foo)
+        expect(process.queue).to eq(:foo)
+      end
     end
 
     describe "#start!" do
@@ -296,6 +313,7 @@ describe Taskinator::Process do
         expect(visitor).to receive(:visit_args).with(:options)
         expect(visitor).to receive(:visit_task_reference).with(:parent)
         expect(visitor).to receive(:visit_tasks)
+        expect(visitor).to receive(:visit_attribute).with(:queue)
 
         subject.accept(visitor)
       }
@@ -330,6 +348,11 @@ describe Taskinator::Process do
           Taskinator::Process.define_concurrent_process_for(Object)
         }.to raise_error(ArgumentError)
       end
+
+      it "sets the queue to use" do
+        process = Taskinator::Process.define_concurrent_process_for(definition, Taskinator::CompleteOn::First, :queue => :foo)
+        expect(process.queue).to eq(:foo)
+      end
     end
 
     describe "#start!" do
@@ -435,6 +458,7 @@ describe Taskinator::Process do
         expect(visitor).to receive(:visit_args).with(:options)
         expect(visitor).to receive(:visit_task_reference).with(:parent)
         expect(visitor).to receive(:visit_tasks)
+        expect(visitor).to receive(:visit_attribute).with(:queue)
 
         subject.accept(visitor)
       }

data/spec/taskinator/process_worker_spec.rb

@@ -41,11 +41,11 @@ describe Taskinator::ProcessWorker do
   it "should fail if process raises an error" do
     process = mock_process
     allow(Taskinator::Process).to receive(:fetch).with(uuid) { process }
-    allow(process).to receive(:start!) { raise NotImplementedError }
-    expect(process).to receive(:fail!).with(NotImplementedError)
+    allow(process).to receive(:start!) { raise StandardError }
+    expect(process).to receive(:fail!).with(StandardError)
     expect {
       subject.perform
-    }.to raise_error(NotImplementedError)
+    }.to raise_error(StandardError)
   end
 
 end

data/spec/taskinator/queues/delayed_job_spec.rb

@@ -7,7 +7,28 @@ describe Taskinator::Queues::DelayedJobAdapter, :delayed_job do
   let(:adapter) { Taskinator::Queues::DelayedJobAdapter }
   let(:uuid) {  SecureRandom.uuid }
 
-  subject { adapter.new() }
+  subject { adapter.new }
+
+  describe "CreateProcessWorker" do
+    let(:args) { Taskinator::Persistence.serialize(:foo => :bar) }
+
+    it "enqueues" do
+      expect {
+        subject.enqueue_create_process(MockDefinition.create, uuid, :foo => :bar)
+      }.to change(Delayed::Job.queue, :size).by(1)
+    end
+
+    it "enqueues to specified queue" do
+      definition = MockDefinition.create(:other)
+      subject.enqueue_create_process(definition, uuid, :foo => :bar)
+      expect(Delayed::Job.contains?(adapter::CreateProcessWorker, [definition.name, uuid, args], :other)).to be
+    end
+
+    it "calls worker" do
+      expect_any_instance_of(Taskinator::CreateProcessWorker).to receive(:perform)
+      adapter::CreateProcessWorker.new(MockDefinition.create.name, uuid, args).perform
+    end
+  end
 
   describe "ProcessWorker" do
     it "enqueues processes" do
@@ -68,11 +89,7 @@ describe Taskinator::Queues::DelayedJobAdapter, :delayed_job do
       adapter::JobWorker.new(uuid).perform
     end
 
-    let(:definition) do
-      Module.new() do
-        extend Taskinator::Definition
-      end
-    end
+    let(:definition) { TestDefinition }
 
     it "performs invocation on job" do
       args = {:a => 1}

data/spec/taskinator/queues/resque_spec.rb

@@ -7,7 +7,32 @@ describe Taskinator::Queues::ResqueAdapter, :resque do
   let(:adapter) { Taskinator::Queues::ResqueAdapter }
   let(:uuid) {  SecureRandom.uuid }
 
-  subject { adapter.new() }
+  subject { adapter.new }
+
+  describe "CreateProcessWorker" do
+    let(:args) { Taskinator::Persistence.serialize(:foo => :bar) }
+
+    it "enqueues" do
+      worker = adapter::CreateProcessWorker
+      definition = MockDefinition.create
+      subject.enqueue_create_process(definition, uuid, :foo => :bar)
+
+      expect(worker).to have_queued(definition.name, uuid, args)
+    end
+
+    it "enqueues to specified queue" do
+      worker = adapter::CreateProcessWorker
+      definition = MockDefinition.create(:other)
+      subject.enqueue_create_process(definition, uuid, :foo => :bar)
+
+      expect(worker).to have_queued(definition.name, uuid, args).in(:other)
+    end
+
+    it "calls worker" do
+      expect_any_instance_of(Taskinator::CreateProcessWorker).to receive(:perform)
+      adapter::CreateProcessWorker.perform(MockDefinition.create.name, uuid, args)
+    end
+  end
 
   describe "ProcessWorker" do
     it "enqueues processes" do
@@ -87,11 +112,7 @@ describe Taskinator::Queues::ResqueAdapter, :resque do
       adapter::JobWorker.perform(uuid)
     end
 
-    let(:definition) do
-      Module.new() do
-        extend Taskinator::Definition
-      end
-    end
+    let(:definition) { TestDefinition }
 
     it "performs invocation on job" do
       args = {:a => 1}

data/spec/taskinator/queues/sidekiq_spec.rb

@@ -9,7 +9,29 @@ describe Taskinator::Queues::SidekiqAdapter, :sidekiq do
   let(:adapter) { Taskinator::Queues::SidekiqAdapter }
   let(:uuid) {  SecureRandom.uuid }
 
-  subject { adapter.new() }
+  subject { adapter.new }
+
+  describe "CreateProcessWorker" do
+    let(:args) { Taskinator::Persistence.serialize(:foo => :bar) }
+
+    it "enqueues" do
+      worker = adapter::CreateProcessWorker
+      definition = MockDefinition.create
+      subject.enqueue_create_process(definition, uuid, :foo => :bar)
+      expect(worker).to have_enqueued_job(definition.name, uuid, args)
+    end
+
+    it "enqueues to specified queue" do
+      subject.enqueue_create_process(MockDefinition.create(:other), uuid, :foo => :bar)
+      expect(adapter::CreateProcessWorker).to be_processed_in_x(:other)
+    end
+
+    it "calls worker" do
+      definition = MockDefinition.create
+      expect_any_instance_of(Taskinator::CreateProcessWorker).to receive(:perform)
+      adapter::CreateProcessWorker.new.perform(definition.name, uuid, args)
+    end
+  end
 
   describe "ProcessWorker" do
     it "enqueues processes" do
@@ -26,7 +48,7 @@ describe Taskinator::Queues::SidekiqAdapter, :sidekiq do
 
     it "calls process worker" do
       expect_any_instance_of(Taskinator::ProcessWorker).to receive(:perform)
-      adapter::ProcessWorker.new().perform(uuid)
+      adapter::ProcessWorker.new.perform(uuid)
     end
   end
 
@@ -45,7 +67,7 @@ describe Taskinator::Queues::SidekiqAdapter, :sidekiq do
 
     it "calls task worker" do
       expect_any_instance_of(Taskinator::TaskWorker).to receive(:perform)
-      adapter::TaskWorker.new().perform(uuid)
+      adapter::TaskWorker.new.perform(uuid)
     end
   end
 
@@ -78,14 +100,10 @@ describe Taskinator::Queues::SidekiqAdapter, :sidekiq do
 
     it "calls job worker" do
       expect_any_instance_of(Taskinator::JobWorker).to receive(:perform)
-      adapter::JobWorker.new().perform(uuid)
+      adapter::JobWorker.new.perform(uuid)
     end
 
-    let(:definition) do
-      Module.new() do
-        extend Taskinator::Definition
-      end
-    end
+    let(:definition) { TestDefinition }
 
     it "performs invocation on job" do
       args = {:a => 1}
@@ -100,7 +118,7 @@ describe Taskinator::Queues::SidekiqAdapter, :sidekiq do
 
       allow(Taskinator::Task).to receive(:fetch).with(uuid) { job_task }
 
-      adapter::JobWorker.new().perform(uuid)
+      adapter::JobWorker.new.perform(uuid)
     end
   end
 end

data/spec/taskinator/task_spec.rb

@@ -2,11 +2,7 @@ require 'spec_helper'
 
 describe Taskinator::Task do
 
-  let(:definition) do
-    Module.new() do
-      extend Taskinator::Definition
-    end
-  end
+  let(:definition) { TestDefinition }
 
   describe "Base" do
 
@@ -36,6 +32,17 @@ describe Taskinator::Task do
       it { expect(subject.to_s).to match(/#{subject.uuid}/) }
     end
 
+    describe "#queue" do
+      it {
+        expect(subject.queue).to be_nil
+      }
+
+      it {
+        task = Class.new(Taskinator::Task).new(process, :queue => :foo)
+        expect(task.queue).to eq(:foo)
+      }
+    end
+
     describe "#current_state" do
       it { expect(subject).to be_a(::Workflow)  }
       it { expect(subject.current_state).to_not be_nil }
@@ -145,10 +152,15 @@ describe Taskinator::Task do
         expect(visitor).to receive(:visit_process_reference).with(:process)
         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)
 
         subject.accept(visitor)
       }
     end
+
+    describe "#reload" do
+      it { expect(subject.reload).to_not be }
+    end
   end
 
   describe Taskinator::Task::Step do
@@ -160,6 +172,13 @@ describe Taskinator::Task do
     let(:process) { Class.new(Taskinator::Process).new(definition) }
     subject { Taskinator::Task.define_step_task(process, :method, {: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)
+        expect(task.queue).to eq(:foo)
+      end
+    end
+
     describe "#executor" do
       it { expect(subject.executor).to_not be_nil }
       it { expect(subject.executor).to be_a(definition) }
@@ -177,6 +196,18 @@ describe Taskinator::Task do
         expect(subject).to receive(:fail!).with(error)
         subject.start!
       end
+
+      it "is instrumented" do
+        allow(subject.executor).to receive(subject.method)
+
+        instrumentation_block = SpecSupport::Block.new
+        expect(instrumentation_block).to receive(:call)
+
+        # temporary subscription
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /execute_step_task/) do
+          subject.start!
+        end
+      end
     end
 
     describe "#can_complete_task?" do
@@ -203,6 +234,7 @@ describe Taskinator::Task do
         expect(visitor).to receive(:visit_args).with(:options)
         expect(visitor).to receive(:visit_attribute).with(:method)
         expect(visitor).to receive(:visit_args).with(:args)
+        expect(visitor).to receive(:visit_attribute).with(:queue)
 
         subject.accept(visitor)
       }
@@ -224,6 +256,13 @@ describe Taskinator::Task do
     let(:process) { Class.new(Taskinator::Process).new(definition) }
     subject { Taskinator::Task.define_job_task(process, TestJob, {:a => 1, :b => 2}) }
 
+    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)
+        expect(task.queue).to eq(:foo)
+      end
+    end
+
     describe "#enqueue!" do
       it {
         expect {
@@ -234,11 +273,24 @@ describe Taskinator::Task do
 
     describe "#perform" do
       it {
-        block = SpecSupport::Block.new()
+        block = SpecSupport::Block.new
         expect(block).to receive(:call).with(TestJob, {:a => 1, :b => 2})
 
-        subject.perform &block
+        subject.perform(&block)
       }
+
+      it "is instrumented" do
+        block = SpecSupport::Block.new
+        allow(block).to receive(:call)
+
+        instrumentation_block = SpecSupport::Block.new
+        expect(instrumentation_block).to receive(:call)
+
+        # temporary subscription
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /execute_job_task/) do
+          subject.perform(&block)
+        end
+      end
     end
 
     describe "#accept" do
@@ -256,6 +308,7 @@ describe Taskinator::Task do
         expect(visitor).to receive(:visit_args).with(:options)
         expect(visitor).to receive(:visit_type).with(:job)
         expect(visitor).to receive(:visit_args).with(:args)
+        expect(visitor).to receive(:visit_attribute).with(:queue)
 
         subject.accept(visitor)
       }
@@ -273,6 +326,13 @@ describe Taskinator::Task do
     let(:sub_process) { Class.new(Taskinator::Process).new(definition) }
     subject { Taskinator::Task.define_sub_process_task(process, sub_process) }
 
+    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)
+        expect(task.queue).to eq(:foo)
+      end
+    end
+
     describe "#start!" do
       it "delegates to sub process" do
         expect(sub_process).to receive(:start)
@@ -285,6 +345,18 @@ describe Taskinator::Task do
         expect(subject).to receive(:fail!).with(error)
         subject.start!
       end
+
+      it "is instrumented" do
+        allow(sub_process).to receive(:start)
+
+        instrumentation_block = SpecSupport::Block.new
+        expect(instrumentation_block).to receive(:call)
+
+        # temporary subscription
+        ActiveSupport::Notifications.subscribed(instrumentation_block, /execute_subprocess/) do
+          subject.start!
+        end
+      end
     end
 
     describe "#can_complete_task?" do
@@ -307,6 +379,7 @@ 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_process).with(:sub_process)
+        expect(visitor).to receive(:visit_attribute).with(:queue)
 
         subject.accept(visitor)
       }

data/spec/taskinator/task_worker_spec.rb

@@ -57,11 +57,11 @@ describe Taskinator::TaskWorker do
   it "should fail if task raises an error" do
     task = mock_task
     allow(Taskinator::Task).to receive(:fetch).with(uuid) { task }
-    allow(task).to receive(:start!) { raise NotImplementedError }
-    expect(task).to receive(:fail!).with(NotImplementedError)
+    allow(task).to receive(:start!) { raise StandardError }
+    expect(task).to receive(:fail!).with(StandardError)
     expect {
       subject.perform
-    }.to raise_error(NotImplementedError)
+    }.to raise_error(StandardError)
   end
 
 end

data/spec/taskinator/{intermodal_spec.rb → taskinator_spec.rb}

@@ -48,10 +48,44 @@ describe Taskinator do
   describe "#logger" do
     it { expect(subject.logger).to_not be_nil }
     it {
-      logger = Logger.new(STDOUT)
+      logger = Logger.new(File::NULL)
       subject.logger = logger
       expect(subject.logger).to eq(logger)
       subject.logger = nil
     }
   end
+
+  describe "#instrumenter" do
+    it { expect(subject.instrumenter).to_not be_nil }
+
+    it {
+      orig_instrumenter = subject.instrumenter
+
+      instrumenter = Class.new().new
+      subject.instrumenter = instrumenter
+      expect(subject.instrumenter).to eq(instrumenter)
+
+      subject.instrumenter = orig_instrumenter
+    }
+
+    it "yields to given block" do
+      block = SpecSupport::Block.new
+      expect(block).to receive(:call)
+
+      subject.instrumenter.instrument(:foo, :bar => :baz, &block)
+    end
+
+    it "instruments event, when activesupport is referenced" do
+      block = SpecSupport::Block.new
+      expect(block).to receive(:call)
+
+      # temporary subscription
+      ActiveSupport::Notifications.subscribed(block, /.*/) do
+        subject.instrumenter.instrument(:foo, :bar) do
+          :baz
+        end
+      end
+    end
+
+  end
 end

data/spec/taskinator/tasks_spec.rb

@@ -17,13 +17,12 @@ describe Taskinator::Tasks do
 
   describe "#initialize" do
     it "starts with nil head" do
-      first = double()
       instance = Taskinator::Tasks.new
       expect(instance.head).to be_nil
     end
 
     it "assigns head to first element" do
-      first = double()
+      first = double
       instance = Taskinator::Tasks.new(first)
       expect(instance.head).to eq(first)
     end

data/taskinator.gemspec

@@ -21,27 +21,29 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = '>= 2.0.0'
 
   # core
-  spec.add_dependency 'redis', '>= 3.2.1'
-  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 'redis'                       , '>= 3.2.1'
+  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.
+  # 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 '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 'delayed_job'     , '>= 4.0.0'
 
-  spec.add_development_dependency 'resque', '>= 1.25.2'
-  spec.add_development_dependency 'resque_spec', '>= 0.16.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 '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'
+  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