taskinator 0.2.0 → 0.3.0

data/spec/taskinator/instrumentation_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Taskinator::Instrumentation, :redis => true do
+
+  let(:definition) { TestDefinition }
+
+  subject do
+    klass = Class.new do
+      include Taskinator::Persistence
+      include Taskinator::Instrumentation
+
+      def self.base_key
+        'base_key'
+      end
+
+      attr_reader :uuid
+      attr_reader :options
+
+      def initialize
+        @uuid = SecureRandom.uuid
+        @options = { :bar => :baz }
+      end
+    end
+
+    klass.new
+  end
+
+  describe "#instrument" do
+    it {
+      event = 'foo_bar'
+
+      expect(Taskinator.instrumenter).to receive(:instrument).with(event, {}).and_call_original
+
+      block = SpecSupport::Block.new
+      expect(block).to receive(:call)
+
+      subject.instrument(event, &block)
+    }
+
+    it {
+      event = 'foo_bar'
+
+      expect(Taskinator.instrumenter).to receive(:instrument).with(event, {:baz => :qux}).and_call_original
+
+      block = SpecSupport::Block.new
+      expect(block).to receive(:call)
+
+      subject.instrument(event, :baz => :qux, &block)
+    }
+  end
+
+  describe "#enqueued_payload" do
+  end
+
+  describe "#processing_payload" do
+  end
+
+  describe "#completed_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],
+          [:tasks_processing, 1],
+          [:tasks_completed, 2],
+          [:tasks_cancelled, 3],
+          [:tasks_failed, 4]
+        )
+      end
+
+      expect(subject.completed_payload(:baz => :qux)).to eq(
+        OpenStruct.new({
+          :type                   => subject.class,
+          :process_uuid           => subject.uuid,
+          :process_options        => {:foo => :bar},
+          :uuid                   => subject.uuid,
+          :state                  => :completed,
+          :options                => subject.options,
+          :percentage_processing  => 1.0,
+          :percentage_completed   => 2.0,
+          :percentage_cancelled   => 3.0,
+          :percentage_failed      => 4.0,
+          :instance               => subject,
+          :baz                    => :qux
+        })
+      )
+    }
+  end
+
+  describe "#cancelled_payload" do
+  end
+
+  describe "#failed_payload" do
+  end
+
+end

data/spec/taskinator/persistence_spec.rb

@@ -30,16 +30,6 @@ describe Taskinator::Persistence, :redis => true do
       }
     end
 
-    describe ".state_for" do
-      before do
-        allow(subject).to receive(:base_key) { 'base_key' }
-      end
-
-      it {
-        expect(subject.state_for('uuid')).to eq(:initial)
-      }
-    end
-
     describe ".fetch" do
       before do
         allow(subject).to receive(:base_key) { 'base_key' }
@@ -320,7 +310,7 @@ describe Taskinator::Persistence, :redis => true do
       describe "#count_#{status}" do
         it {
           Taskinator.redis do |conn|
-            conn.hset(subject.process_key, status, 99)
+            conn.hset(subject.process_key, "tasks_#{status}", 99)
           end
 
           expect(subject.send(:"count_#{status}")).to eq(99)
@@ -330,7 +320,7 @@ describe Taskinator::Persistence, :redis => true do
       describe "#incr_#{status}" do
         it {
           Taskinator.redis do |conn|
-            conn.hset(subject.process_key, status, 99)
+            conn.hset(subject.process_key, "tasks_#{status}", 99)
           end
 
           subject.send(:"incr_#{status}")
@@ -345,7 +335,7 @@ describe Taskinator::Persistence, :redis => true do
             conn.hmset(
               subject.process_key,
               [:tasks_count, 100],
-              [status, 1]
+              ["tasks_#{status}", 1]
             )
           end
 
@@ -365,33 +355,5 @@ describe Taskinator::Persistence, :redis => true do
       }
     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

data/spec/taskinator/process_spec.rb

@@ -6,7 +6,11 @@ describe Taskinator::Process do
 
   describe "Base" do
 
-    subject { Class.new(Taskinator::Process).new(definition) }
+    subject do
+      Class.new(Taskinator::Process) do
+        include ProcessMethods
+      end.new(definition)
+    end
 
     describe "#initialize" do
       it { expect(subject.uuid).to_not be_nil }
@@ -47,17 +51,9 @@ describe Taskinator::Process 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) }
-    end
-
-    describe "#tasks_completed?" do
-      it {
-        expect {
-          subject.tasks_completed?
-        }.to raise_error(NotImplementedError)
-      }
+      it { expect(subject.current_state).to eq(:initial) }
     end
 
     describe "workflow" do
@@ -70,9 +66,9 @@ describe Taskinator::Process do
         }
 
         it {
-          expect(subject.current_state.name).to eq(:initial)
+          expect(subject.current_state).to eq(:initial)
           subject.enqueue!
-          expect(subject.current_state.name).to eq(:enqueued)
+          expect(subject.current_state).to eq(:enqueued)
         }
       end
 
@@ -83,9 +79,9 @@ describe Taskinator::Process do
           subject.start!
         }
         it {
-          expect(subject.current_state.name).to eq(:initial)
+          expect(subject.current_state).to eq(:initial)
           subject.start!
-          expect(subject.current_state.name).to eq(:processing)
+          expect(subject.current_state).to eq(:processing)
         }
       end
 
@@ -96,9 +92,9 @@ describe Taskinator::Process do
           subject.cancel!
         }
         it {
-          expect(subject.current_state.name).to eq(:initial)
+          expect(subject.current_state).to eq(:initial)
           subject.cancel!
-          expect(subject.current_state.name).to eq(:cancelled)
+          expect(subject.current_state).to eq(:cancelled)
         }
       end
 
@@ -112,7 +108,7 @@ describe Taskinator::Process do
         it {
           subject.start!
           subject.pause!
-          expect(subject.current_state.name).to eq(:paused)
+          expect(subject.current_state).to eq(:paused)
         }
       end
 
@@ -128,7 +124,7 @@ describe Taskinator::Process do
           subject.start!
           subject.pause!
           subject.resume!
-          expect(subject.current_state.name).to eq(:processing)
+          expect(subject.current_state).to eq(:processing)
         }
       end
 
@@ -143,21 +139,22 @@ describe Taskinator::Process do
         it {
           subject.start!
           subject.complete!
-          expect(subject.current_state.name).to eq(:completed)
+          expect(subject.current_state).to eq(:completed)
         }
       end
 
       describe "#fail!" do
         it { expect(subject).to respond_to(:fail!) }
         it {
-          expect(subject).to receive(:fail)
+          error = StandardError.new
+          expect(subject).to receive(:fail).with(error)
           subject.start!
-          subject.fail!
+          subject.fail!(error)
         }
         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
     end
@@ -176,7 +173,7 @@ describe Taskinator::Process do
         subject.parent = double('parent')
         expect(subject.parent).to receive(:fail!)
         subject.start!
-        subject.fail!
+        subject.fail!(StandardError.new)
       end
     end
 
@@ -196,6 +193,8 @@ describe Taskinator::Process do
         expect(visitor).to receive(:visit_task_reference).with(:parent)
         expect(visitor).to receive(:visit_tasks)
         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)
       }
@@ -211,12 +210,10 @@ describe Taskinator::Process do
 
   describe Taskinator::Process::Sequential do
 
-    it_should_behave_like "a process", Taskinator::Process::Sequential do
-      let(:process) { Taskinator::Process.define_sequential_process_for(definition) }
-    end
-
     subject { Taskinator::Process.define_sequential_process_for(definition) }
 
+    it_should_behave_like "a process", Taskinator::Process::Sequential
+
     let(:tasks) {
       [
         Class.new(Taskinator::Task).new(subject),
@@ -333,6 +330,8 @@ describe Taskinator::Process do
         expect(visitor).to receive(:visit_task_reference).with(:parent)
         expect(visitor).to receive(:visit_tasks)
         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)
       }
@@ -344,13 +343,14 @@ describe Taskinator::Process do
   end
 
   describe Taskinator::Process::Concurrent do
+
+    subject { Taskinator::Process.define_concurrent_process_for(definition) }
+
     it_should_behave_like "a process", Taskinator::Process::Concurrent do
-      let(:process) { Taskinator::Process.define_concurrent_process_for(definition, Taskinator::CompleteOn::First) }
 
-      it { expect(process.complete_on).to eq(Taskinator::CompleteOn::First)  }
-    end
+      it { expect(subject.complete_on).to eq(Taskinator::CompleteOn::Default)  }
 
-    subject { Taskinator::Process.define_concurrent_process_for(definition) }
+    end
 
     let(:tasks) {
       [
@@ -495,11 +495,13 @@ describe Taskinator::Process do
         visitor = double('visitor')
         expect(visitor).to receive(:visit_type).with(:definition)
         expect(visitor).to receive(:visit_attribute).with(:uuid)
-        expect(visitor).to receive(:visit_attribute).with(:complete_on)
+        expect(visitor).to receive(:visit_attribute_enum).with(:complete_on, Taskinator::CompleteOn)
         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)
+        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/queues/delayed_job_spec.rb

@@ -48,45 +48,4 @@ describe Taskinator::Queues::DelayedJobAdapter, :delayed_job do
     end
   end
 
-  describe "JobWorker" do
-    it "enqueues jobs" do
-      job = double('job')
-      job_task = double('job_task', :uuid => uuid, :job => job, :queue => nil)
-
-      expect {
-        subject.enqueue_job(job_task)
-      }.to change(Delayed::Job.queue, :size).by(1)
-    end
-
-    it "enqueues job to specified queue" do
-      job = double('job')
-      job_task = double('job_task', :uuid => uuid, :job => job, :queue => :other)
-      subject.enqueue_job(job_task)
-
-      expect(Delayed::Job.contains?(adapter::JobWorker, uuid, :other)).to be
-    end
-
-    it "calls job worker" do
-      expect_any_instance_of(Taskinator::JobWorker).to receive(:perform)
-      adapter::JobWorker.new(uuid).perform
-    end
-
-    let(:definition) { TestDefinition }
-
-    it "performs invocation on job" do
-      args = [:foo, {:a => 1}]
-      job = double('job')
-      expect(job).to receive(:perform)
-
-      job_class = double('job_class', :instance_methods => [:perform])
-      allow(job_class).to receive(:new).with(*args) { job }
-
-      process = Taskinator::Process::Sequential.new(definition)
-      job_task = Taskinator::Task.define_job_task(process, job_class, args)
-
-      allow(Taskinator::Task).to receive(:fetch).with(uuid) { job_task }
-
-      adapter::JobWorker.new(uuid).perform
-    end
-  end
 end

data/spec/taskinator/queues/resque_spec.rb

@@ -55,55 +55,4 @@ describe Taskinator::Queues::ResqueAdapter, :resque do
     end
   end
 
-  describe "JobWorker" do
-    it "enqueues jobs" do
-      worker = adapter::JobWorker
-
-      job = double('job')
-      job_task = double('job_task', :uuid => uuid, :job => job, :queue => nil)
-
-      subject.enqueue_job(job_task)
-      expect(worker).to have_queued(uuid)
-    end
-
-    it "enqueues job to queue of the job class" do
-      worker = adapter::JobWorker
-
-      job = double('job', :queue => :job)
-      job_task = double('job_task', :uuid => uuid, :job => job, :queue => nil)
-
-      subject.enqueue_job(job_task)
-      expect(worker).to have_queued(uuid).in(:job)
-    end
-
-    it "enqueues job to specified queue" do
-      worker = adapter::JobWorker
-
-      job = double('job')
-      job_task = double('job_task', :uuid => uuid, :job => job, :queue => :other)
-
-      subject.enqueue_job(job_task)
-      expect(worker).to have_queued(uuid).in(:other)
-    end
-
-    it "calls job worker" do
-      expect_any_instance_of(Taskinator::JobWorker).to receive(:perform)
-      adapter::JobWorker.perform(uuid)
-    end
-
-    let(:definition) { TestDefinition }
-
-    it "performs invocation on job" do
-      args = [:foo, {:a => 1}]
-      job_class = double('job_class', :methods => [:perform])
-      expect(job_class).to receive(:perform).with(*args)
-
-      process = Taskinator::Process::Sequential.new(definition)
-      job_task = Taskinator::Task.define_job_task(process, job_class, args)
-
-      allow(Taskinator::Task).to receive(:fetch).with(uuid) { job_task }
-
-      adapter::JobWorker.perform(uuid)
-    end
-  end
 end

data/spec/taskinator/queues/sidekiq_spec.rb

@@ -52,54 +52,4 @@ describe Taskinator::Queues::SidekiqAdapter, :sidekiq do
     end
   end
 
-  describe "JobWorker" do
-    it "enqueues jobs" do
-      worker = adapter::JobWorker
-
-      job = double('job', :get_sidekiq_options => {})
-      job_task = double('job_task', :uuid => uuid, :job => job, :queue => nil)
-
-      subject.enqueue_job(job_task)
-      expect(worker).to have_enqueued_job(job_task.uuid)
-    end
-
-    it "enqueues job to queue of the job class" do
-      job = double('job', :get_sidekiq_options => {:queue => :job})
-      job_task = double('job_task', :uuid => uuid, :job => job, :queue => nil)
-      subject.enqueue_job(job_task)
-
-      expect(adapter::JobWorker).to be_processed_in_x(:job)
-    end
-
-    it "enqueues job to specified queue" do
-      job = double('job', :get_sidekiq_options => {})
-      job_task = double('job_task', :uuid => uuid, :job => job, :queue => :other)
-      subject.enqueue_job(job_task)
-
-      expect(adapter::JobWorker).to be_processed_in_x(:other)
-    end
-
-    it "calls job worker" do
-      expect_any_instance_of(Taskinator::JobWorker).to receive(:perform)
-      adapter::JobWorker.new.perform(uuid)
-    end
-
-    let(:definition) { TestDefinition }
-
-    it "performs invocation on job" do
-      args = [:foo, {:a => 1}]
-      job = double('job')
-      expect(job).to receive(:perform).with(*args)
-
-      job_class = double('job_class', :get_sidekiq_options => {}, :instance_methods => [:perform])
-      allow(job_class).to receive(:new) { job }
-
-      process = Taskinator::Process::Sequential.new(definition)
-      job_task = Taskinator::Task.define_job_task(process, job_class, args)
-
-      allow(Taskinator::Task).to receive(:fetch).with(uuid) { job_task }
-
-      adapter::JobWorker.new.perform(uuid)
-    end
-  end
 end

data/spec/taskinator/queues_spec.rb

@@ -5,7 +5,7 @@ describe Taskinator::Queues do
   it "raise error for an unknown adapter" do
     expect {
       Taskinator::Queues.create_adapter(:unknown)
-    }.to raise_error
+    }.to raise_error(StandardError)
   end
 
   it "passes configuration to adapter initializer" do