taskinator 0.4.7 → 0.5.1

data/spec/taskinator/definition_spec.rb

@@ -106,6 +106,37 @@ describe Taskinator::Definition do
       expect(subject.create_process).to be_a(Taskinator::Process)
     end
 
+    it "handles error" do
+      subject.define_process do
+        raise ArgumentError
+      end
+
+      expect {
+        subject.create_process
+      }.to raise_error(ArgumentError)
+    end
+
+    it "checks defined arguments provided" do
+      subject.define_process :arg1, :arg2 do
+      end
+
+      expect {
+        subject.create_process
+      }.to raise_error(ArgumentError)
+
+      expect {
+        subject.create_process :foo
+      }.to raise_error(ArgumentError)
+
+      expect {
+        subject.create_process :foo, :bar
+      }.not_to raise_error
+
+      expect {
+        subject.create_process :foo, :bar, :baz
+      }.not_to raise_error
+    end
+
     it "defaults the scope to :shared" do
       block = SpecSupport::Block.new
       allow(block).to receive(:to_proc) {
@@ -156,7 +187,7 @@ describe Taskinator::Definition do
       # if an error is raised, then the context was incorrect
       expect {
         subject.create_process
-      }.to_not raise_error(StandardError)
+      }.not_to raise_error
     end
 
     context "is instrumented" do

data/spec/taskinator/instrumentation_spec.rb

@@ -2,8 +2,6 @@ require 'spec_helper'
 
 describe Taskinator::Instrumentation, :redis => true do
 
-  let(:definition) { TestDefinition }
-
   subject do
     klass = Class.new do
       include Taskinator::Persistence
@@ -15,10 +13,12 @@ describe Taskinator::Instrumentation, :redis => true do
 
       attr_reader :uuid
       attr_reader :options
+      attr_reader :definition
 
       def initialize
         @uuid = Taskinator.generate_uuid
         @options = { :bar => :baz }
+        @definition = TestDefinition
       end
     end
 
@@ -75,6 +75,7 @@ describe Taskinator::Instrumentation, :redis => true do
       expect(subject.completed_payload(:baz => :qux)).to eq(
         OpenStruct.new({
           :type                   => subject.class.name,
+          :definition             => subject.definition.name,
           :process_uuid           => subject.uuid,
           :process_options        => {:foo => :bar},
           :uuid                   => subject.uuid,

data/spec/taskinator/persistence_spec.rb

@@ -46,6 +46,15 @@ describe Taskinator::Persistence, :redis => true do
         expect(subject.fetch('uuid', cache)).to eq(item)
       end
 
+      it "yields UnknownType" do
+        Taskinator.redis do |conn|
+          conn.hmset(*[subject.key_for("foo"), [:type, 'UnknownFoo']])
+        end
+        instance = subject.fetch("foo")
+        expect(instance).to be_a(Taskinator::Persistence::UnknownType)
+        expect(instance.type).to eq("UnknownFoo")
+      end
+
       describe "for processes" do
         let(:process) { TestProcess.new(definition) }
 
@@ -53,6 +62,19 @@ describe Taskinator::Persistence, :redis => true do
           process.save
           expect(TestProcess.fetch(process.uuid)).to eq(process)
         }
+
+        describe "unknown definition" do
+          it "yields UnknownType" do
+            Taskinator.redis do |conn|
+              conn.hmset(*[process.key, [:type, TestProcess.name], [:uuid, process.uuid], [:definition, 'UnknownFoo']])
+            end
+
+            instance = TestProcess.fetch(process.uuid)
+            expect(instance.uuid).to eq(process.uuid)
+            expect(instance.definition).to be_a(Taskinator::Persistence::UnknownType)
+            expect(instance.definition.type).to eq("UnknownFoo")
+          end
+        end
       end
 
       describe "for tasks" do
@@ -62,9 +84,45 @@ describe Taskinator::Persistence, :redis => true do
         it {
           process.tasks << task
           process.save
-          expect(TestTask.fetch(task.uuid)).to eq(task)
-          expect(TestTask.fetch(task.uuid).process).to eq(process)
+
+          instance = TestTask.fetch(task.uuid)
+          expect(instance).to eq(task)
+          expect(instance.process).to eq(process)
         }
+
+        describe "unknown job" do
+          let(:task) { TestJobTask.new(process, TestJob, []) }
+
+          it "yields UnknownType" do
+            Taskinator.redis do |conn|
+              conn.hmset(*[task.key, [:type, task.class.name], [:uuid, task.uuid], [:job, 'UnknownBar']])
+            end
+
+            instance = TestJobTask.fetch(task.uuid)
+            expect(instance.uuid).to eq(task.uuid)
+            expect(instance.job).to be_a(Taskinator::Persistence::UnknownType)
+            expect(instance.job.type).to eq("UnknownBar")
+          end
+        end
+
+        describe "unknown subprocess" do
+          let(:sub_process) { TestProcess.new(definition) }
+          let(:task) { TestSubProcessTask.new(process, sub_process) }
+
+          it "yields UnknownType" do
+            Taskinator.redis do |conn|
+              conn.multi do |transaction|
+                transaction.hmset(*[task.key, [:type, task.class.name], [:uuid, task.uuid], [:sub_process, sub_process.uuid]])
+                transaction.hmset(*[sub_process.key, [:type, sub_process.class.name], [:uuid, sub_process.uuid], [:definition, 'UnknownBaz']])
+              end
+            end
+
+            instance = TestSubProcessTask.fetch(task.uuid)
+            expect(instance.uuid).to eq(task.uuid)
+            expect(instance.sub_process.definition).to be_a(Taskinator::Persistence::UnknownType)
+            expect(instance.sub_process.definition.type).to eq("UnknownBaz")
+          end
+        end
       end
     end
   end
@@ -188,6 +246,72 @@ describe Taskinator::Persistence, :redis => true do
     end
   end
 
+  describe "unknown type helpers" do
+    subject { Taskinator::Persistence::UnknownType }
+
+    describe "#new" do
+      it "instantiates new module instance" do
+        instance = subject.new("foo")
+        expect(instance).to_not be_nil
+        expect(instance).to be_a(::Module)
+      end
+
+      it "yields same instance for same type" do
+        instance1 = subject.new("foo")
+        instance2 = subject.new("foo")
+        expect(instance1).to eq(instance2)
+      end
+    end
+
+    describe ".type" do
+      it {
+        instance = subject.new("foo")
+        expect(instance.type).to eq("foo")
+      }
+    end
+
+    describe ".to_s" do
+      it {
+        instance = subject.new("foo")
+        expect(instance.to_s).to eq("Unknown type 'foo'.")
+      }
+    end
+
+    describe ".allocate" do
+      it "emulates Object#allocate" do
+        instance = subject.new("foo")
+        expect(instance.allocate).to eq(instance)
+      end
+    end
+
+    describe ".accept" do
+      it {
+        instance = subject.new("foo")
+        expect(instance).to respond_to(:accept)
+      }
+    end
+
+    describe ".perform" do
+      it "raises UnknownTypeError" do
+        instance = subject.new("foo")
+        expect {
+          instance.perform(:foo, 1, false)
+        }.to raise_error(Taskinator::Persistence::UnknownTypeError)
+      end
+    end
+
+    describe "via executor" do
+      it "raises UnknownTypeError" do
+        instance = subject.new("foo")
+        executor = Taskinator::Executor.new(instance)
+
+        expect {
+          executor.foo
+        }.to raise_error(Taskinator::Persistence::UnknownTypeError)
+      end
+    end
+  end
+
   describe "instance methods" do
     subject {
       klass = Class.new do
@@ -207,11 +331,14 @@ describe Taskinator::Persistence, :redis => true do
     }
 
     describe "#save" do
-      pending __FILE__
+      pending
     end
 
     describe "#to_xml" do
-      pending __FILE__
+      it {
+        process = TestFlows::Task.create_process(1)
+        expect(process.to_xml).to match(/xml/)
+      }
     end
 
     describe "#key" do
@@ -426,6 +553,5 @@ describe Taskinator::Persistence, :redis => true do
       end
 
     end
-
   end
 end

data/spec/taskinator/process_spec.rb

@@ -35,6 +35,14 @@ describe Taskinator::Process do
       it { expect(subject.tasks).to be_a(Taskinator::Tasks) }
     end
 
+    describe "#no_tasks_defined?" do
+      it { expect(subject.no_tasks_defined?).to be }
+      it {
+        subject.tasks << :mock
+        expect(subject.no_tasks_defined?).to_not be
+      }
+    end
+
     describe "#to_s" do
       it { expect(subject.to_s).to match(/#{subject.uuid}/) }
     end
@@ -288,7 +296,7 @@ describe Taskinator::Process do
         subject.task_completed(task1)
       end
 
-      it "deincrements the pending task count" do
+      it "decrements the pending task count" do
         tasks.each {|t| subject.tasks << t }
         task1 = tasks[0]
         task2 = tasks[1]
@@ -367,7 +375,7 @@ describe Taskinator::Process do
         subject.task_failed(tasks.first, error)
       end
 
-      it "doesn't deincement pending task count" do
+      it "doesn't decrement pending task count" do
         tasks.each {|t| subject.tasks << t }
 
         expect(subject).to_not receive(:deincr_pending_tasks)
@@ -515,7 +523,7 @@ describe Taskinator::Process do
         end
       end
 
-      it "deincrements the pending task count" do
+      it "decrements the pending task count" do
         tasks.each {|t| subject.tasks << t }
         task1 = tasks[0]
         task2 = tasks[1]

data/spec/taskinator/queues/active_job_spec.rb

@@ -35,27 +35,6 @@ describe Taskinator::Queues::ActiveJobAdapter, :active_job 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_been_enqueued.with(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_been_enqueued.with(uuid).on_queue(: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

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 {

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

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_sidekiq_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

data/spec/taskinator/queues/test_queue_adapter_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Taskinator::Queues::TestQueueAdapter do
+
+  # sanity check for the test adapter
+
+  it_should_behave_like "a queue adapter", :test_queue, Taskinator::Queues::TestQueueAdapter
+
+end

data/spec/taskinator/task_spec.rb

@@ -93,6 +93,16 @@ describe Taskinator::Task do
         }
       end
 
+      describe "#cancel!" do
+        it { expect(subject).to respond_to(:cancel!) }
+        it {
+          expect(subject).to receive(:cancel)
+          subject.start!
+          subject.cancel!
+          expect(subject.current_state).to eq(:cancelled)
+        }
+      end
+
       describe "#fail!" do
         it { expect(subject).to respond_to(:fail!) }
         it {
@@ -144,6 +154,7 @@ describe Taskinator::Task do
         visitor = double('visitor')
         expect(visitor).to receive(:visit_attribute).with(:uuid)
         expect(visitor).to receive(:visit_process_reference).with(:process)
+        expect(visitor).to receive(:visit_type).with(:definition)
         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)
@@ -250,6 +261,18 @@ describe Taskinator::Task do
         expect(exec_context.options).to eq(subject.options)
       end
 
+      it "throws an exception for unknown definition type" do
+        executor = Taskinator::Executor.new(Taskinator::Persistence::UnknownType.new("Foo"), subject)
+
+        # replace the internal executor instance for the task
+        # with this one, so we can hook into the methods
+        subject.instance_eval { @executor = executor }
+
+        expect {
+          subject.start!
+        }.to raise_error(Taskinator::Persistence::UnknownTypeError)
+      end
+
       it "is instrumented" do
         instrumentation_block = SpecSupport::Block.new
 
@@ -314,36 +337,12 @@ describe Taskinator::Task do
 
     describe "#inspect" do
       it { expect(subject.inspect).to_not be_nil }
+      it { expect(subject.inspect).to include(definition.name) }
     end
   end
 
   describe Taskinator::Task::Job do
 
-    module TestJob
-      def self.perform(*args)
-      end
-    end
-
-    class TestJobClass
-      def perform(*args)
-      end
-    end
-
-    module TestJobModule
-      def self.perform(*args)
-      end
-    end
-
-    class TestJobClassNoArgs
-      def perform
-      end
-    end
-
-    module TestJobModuleNoArgs
-      def self.perform
-      end
-    end
-
     subject { Taskinator::Task.define_job_task(process, TestJob, [1, {:a => 1, :b => 2}]) }
 
     it_should_behave_like "a task", Taskinator::Task::Job
@@ -404,6 +403,22 @@ describe Taskinator::Task do
         task.start!
       }
 
+      it "throws an exception when unknown job type" do
+        task = Taskinator::Task.define_job_task(process, Taskinator::Persistence::UnknownType.new("Foo"), nil)
+
+        expect {
+          task.start!
+        }.to raise_error(Taskinator::Persistence::UnknownTypeError)
+      end
+
+      it "handles failure" do
+        task = Taskinator::Task.define_job_task(process, TestJobError, nil)
+
+        expect {
+          task.start!
+        }.to raise_error(ArgumentError)
+      end
+
       it "is instrumented" do
         allow(process).to receive(:task_completed).with(subject)
 
@@ -473,6 +488,7 @@ describe Taskinator::Task do
 
     describe "#inspect" do
       it { expect(subject.inspect).to_not be_nil }
+      it { expect(subject.inspect).to include(definition.name) }
     end
   end
 
@@ -582,6 +598,7 @@ describe Taskinator::Task do
         visitor = double('visitor')
         expect(visitor).to receive(:visit_attribute).with(:uuid)
         expect(visitor).to receive(:visit_process_reference).with(:process)
+        expect(visitor).to receive(:visit_type).with(:definition)
         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)
@@ -595,6 +612,7 @@ describe Taskinator::Task do
 
     describe "#inspect" do
       it { expect(subject.inspect).to_not be_nil }
+      it { expect(subject.inspect).to include(definition.name) }
     end
   end
 

data/spec/taskinator/taskinator_spec.rb

@@ -86,6 +86,22 @@ describe Taskinator do
         end
       end
     end
+  end
+
+  [
+    Taskinator::NoOpInstrumenter,
+    Taskinator::ConsoleInstrumenter
+  ].each do |instrumenter|
+    describe instrumenter do
+      it "yields to given block" do
+        instance = instrumenter.new
+
+        block = SpecSupport::Block.new
+        expect(block).to receive(:call)
 
+        instance.instrument(:foo, :bar => :baz, &block)
+      end
+    end
   end
+
 end

data/spec/taskinator/test_flows_spec.rb

@@ -98,10 +98,14 @@ describe TestFlows do
         let(:definition) { TestFlows::EmptySequentialProcessTest }
         subject { definition.create_process }
 
+        it "contains 3 tasks" do
+          expect(subject.tasks.length).to eq(3)
+        end
+
         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_any_instance_of(definition).to receive(:task_0)
+          expect_any_instance_of(definition).to receive(:task_1)
+          expect_any_instance_of(definition).to receive(:task_2)
 
           expect {
             subject.enqueue!
@@ -113,10 +117,14 @@ describe TestFlows do
         let(:definition) { TestFlows::EmptyConcurrentProcessTest }
         subject { definition.create_process }
 
+        it "contains 3 tasks" do
+          expect(subject.tasks.length).to eq(3)
+        end
+
         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_any_instance_of(definition).to receive(:task_0)
+          expect_any_instance_of(definition).to receive(:task_1)
+          expect_any_instance_of(definition).to receive(:task_2)
 
           expect {
             subject.enqueue!
@@ -173,11 +181,11 @@ describe TestFlows do
     end
 
     describe "job" do
-
+      pending
     end
 
     describe "subprocess" do
-
+      pending
     end
   end
 

data/taskinator.gemspec

@@ -26,8 +26,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'connection_pool'             , '>= 2.2.0'
   spec.add_dependency 'json'                        , '>= 1.8.2'
   spec.add_dependency 'builder'                     , '>= 3.2.2'
-  spec.add_dependency 'globalid'                    , '~> 0.3'
-  spec.add_dependency 'statsd-ruby'                 , '~> 1.4.0'
-  spec.add_dependency 'thwait'                      , '~> 0.2'
+  spec.add_dependency 'globalid'                    , '>= 0.3'
+  spec.add_dependency 'thwait'                      , '>= 0.2'
 
 end