taskinator 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 733dcb0269d80bc0685527f80cbfa4fc76476d25
-  data.tar.gz: 0d67598fedf6988febd3fb74126243f31868a99b
+  metadata.gz: 3ae6a63807d0e3e2cb0c513f348eeab155abe830
+  data.tar.gz: ce5a3c1168ff6a3d1bcb623452c458dac6b96dee
 SHA512:
-  metadata.gz: 4b0a72311954c8f95d6d20619487fecb754e68e0fc6fdd6dee087fa882db321a56644ac06a8bb2f997252656ebf62598b7227a9c0f9c79867643d470a5fbabf1
-  data.tar.gz: 8608aa783cc093aa559ad3513ea308234b16092fbd70299034a3d90f6d505d3eeb9378a11c602851a748553c2846f49f0f3670629d350e75a7b5e548a059b7f6
+  metadata.gz: 5da9ab4636b65d268ed99c45679433c37fe6c7097c7af6c26bbc8a03e08362f3ac6709da209c43950428a6f2b43b1df3a37242e4f28602ca378ec6d40f9063cf
+  data.tar.gz: d538da07fdd101f86077ad08d2415fc87fab6df2d89327c6df530b56b4f93deaee633095d0fec1633cfc55ae50faa64fb7697614920dcd83bee24a8e33a6b8d3

data/Gemfile.lock

@@ -8,7 +8,7 @@ GIT
 PATH
   remote: .
   specs:
-    taskinator (0.0.3)
+    taskinator (0.0.4)
       connection_pool (>= 2.0.0)
       json (>= 1.8.1)
       redis (>= 3.0.6)
@@ -17,7 +17,7 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (4.1.5)
+    activesupport (4.1.6)
       i18n (~> 0.6, >= 0.6.9)
       json (~> 1.7, >= 1.7.7)
       minitest (~> 5.1)
@@ -38,7 +38,7 @@ GEM
       term-ansicolor
       thor
     debugger-linecache (1.2.0)
-    delayed_job (4.0.2)
+    delayed_job (4.0.3)
       activesupport (>= 3.0, < 4.2)
     diff-lcs (1.2.5)
     docile (1.1.5)
@@ -78,20 +78,20 @@ GEM
     rest-client (1.7.2)
       mime-types (>= 1.16, < 3.0)
       netrc (~> 0.7)
-    rspec (3.0.0)
-      rspec-core (~> 3.0.0)
-      rspec-expectations (~> 3.0.0)
-      rspec-mocks (~> 3.0.0)
-    rspec-core (3.0.4)
-      rspec-support (~> 3.0.0)
-    rspec-expectations (3.0.4)
+    rspec (3.1.0)
+      rspec-core (~> 3.1.0)
+      rspec-expectations (~> 3.1.0)
+      rspec-mocks (~> 3.1.0)
+    rspec-core (3.1.2)
+      rspec-support (~> 3.1.0)
+    rspec-expectations (3.1.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.0.0)
-    rspec-mocks (3.0.4)
-      rspec-support (~> 3.0.0)
-    rspec-support (3.0.4)
-    sidekiq (3.2.3)
-      celluloid (>= 0.15.2)
+      rspec-support (~> 3.1.0)
+    rspec-mocks (3.1.0)
+      rspec-support (~> 3.1.0)
+    rspec-support (3.1.0)
+    sidekiq (3.2.5)
+      celluloid (= 0.15.2)
       connection_pool (>= 2.0.0)
       json
       redis (>= 3.0.6)

data/lib/taskinator/definition/builder.rb

@@ -49,6 +49,15 @@ module Taskinator
         define_step_task(@process, method, @args, options)
       end
 
+      # defines a task which executes the given @job
+      # which is expected to implement a perform method either as a class or instance method
+      def job(job, options={})
+        raise ArgumentError, 'job' if job.nil?
+        raise ArgumentError, 'job' unless job.methods.include?(:perform) || job.instance_methods.include?(:perform)
+
+        define_job_task(@process, job, @args, options)
+      end
+
       # defines a sub process task, for the given @definition
       # the definition specified must have input compatible arguments
       # to the current definition
@@ -70,6 +79,12 @@ module Taskinator
         }
       end
 
+      def define_job_task(process, job, args, options={})
+        define_task(process) {
+          Task.define_job_task(process, job, args, options)
+        }
+      end
+
       def define_sub_process_task(process, sub_process, options={})
         define_task(process) {
           Task.define_sub_process_task(process, sub_process, options)

data/lib/taskinator/job_worker.rb

@@ -0,0 +1,20 @@
+module Taskinator
+  class JobWorker
+    def initialize(uuid)
+      @uuid = uuid
+    end
+
+    # NB: must be provided a block for the implmentation of the job execution
+    def perform(&block)
+      task = Taskinator::Task.fetch(@uuid)
+      return if task.paused? || task.cancelled?
+      begin
+        task.start!
+        task.perform &block
+        task.complete!
+      rescue Exception => e
+        task.fail!(e)
+      end
+    end
+  end
+end

data/lib/taskinator/persistence.rb

@@ -168,8 +168,24 @@ module Taskinator
       end
 
       def visit_args(attribute)
-        value = @instance.send(attribute)
-        @hmset += [attribute, YAML.dump(value)] if value
+        values = @instance.send(attribute)
+
+        # special case, convert models to global id's
+        if values.is_a?(Array)
+
+          values = values.collect {|value|
+            value.respond_to?(:global_id) ? value.global_id : value
+          }
+
+        elsif values.is_a?(Hash)
+
+          values.each {|key, value|
+            values[key] = value.global_id if value.respond_to?(:global_id)
+          }
+
+        end
+
+        @hmset += [attribute, YAML.dump(values)]
       end
     end
 
@@ -258,10 +274,26 @@ module Taskinator
 
       # deserializes the arguments using YAML#load method
       def visit_args(attribute)
-        value = @attribute_values[attribute]
-        if value
-          args = YAML.load(value)
-          @instance.instance_variable_set("@#{attribute}", args)
+        yaml = @attribute_values[attribute]
+        if yaml
+          values = YAML.load(yaml)
+
+          # special case for models, so find model
+          if values.is_a?(Array)
+
+            values = values.collect {|value|
+              value.respond_to?(:find) ? value.find : value
+            }
+
+          elsif values.is_a?(Hash)
+
+            values.each {|key, value|
+              values[key] = value.find if value.respond_to?(:find)
+            }
+
+          end
+
+          @instance.instance_variable_set("@#{attribute}", values)
         end
       end
 

data/lib/taskinator/queues/delayed_job.rb

@@ -11,7 +11,8 @@ module Taskinator
       def initialize(config={})
         @config = {
           :process_queue => :default,
-          :task_queue => :default
+          :task_queue => :default,
+          :job_queue => :default,
         }.merge(config)
       end
 
@@ -23,6 +24,11 @@ module Taskinator
         ::Delayed::Job.enqueue TaskWorker.new(task.uuid), :queue => @config[:task_queue]
       end
 
+      def enqueue_job(job)
+        # delayed jobs don't define the queue so use the configured queue instead
+        ::Delayed::Job.enqueue JobWorker.new(job.uuid), :queue => @config[:job_queue]
+      end
+
       ProcessWorker = Struct.new(:process_uuid) do
         def perform
           Taskinator::ProcessWorker.new(process_uuid).perform
@@ -34,6 +40,14 @@ module Taskinator
           Taskinator::TaskWorker.new(task_uuid).perform
         end
       end
+
+      JobWorker = Struct.new(:job_uuid) do
+        def perform
+          Taskinator::JobWorker.new(job_uuid).perform do |job, args|
+            job.new(*args).perform
+          end
+        end
+      end
     end
   end
 end

data/lib/taskinator/queues/resque.rb

@@ -11,7 +11,8 @@ module Taskinator
       def initialize(config={})
         config = {
           :process_queue => :default,
-          :task_queue => :default
+          :task_queue => :default,
+          :job_queue => :default
         }.merge(config)
 
         ProcessWorker.class_eval do
@@ -21,6 +22,10 @@ module Taskinator
         TaskWorker.class_eval do
           @queue = config[:task_queue]
         end
+
+        JobWorker.class_eval do
+          @queue = config[:job_queue]
+        end
       end
 
       def enqueue_process(process)
@@ -31,6 +36,14 @@ module Taskinator
         Resque.enqueue(TaskWorker, task.uuid)
       end
 
+      def enqueue_job(job)
+        # get the queue name
+        queue = Resque.queue_from_class(job.job) ||
+                  Resque.queue_from_class(JobWorker)
+
+        Resque.enqueue_to(queue, JobWorker, job.uuid)
+      end
+
       class ProcessWorker
         def self.perform(process_uuid)
           Taskinator::ProcessWorker.new(process_uuid).perform
@@ -42,6 +55,14 @@ module Taskinator
           Taskinator::TaskWorker.new(task_uuid).perform
         end
       end
+
+      class JobWorker
+        def self.perform(job_uuid)
+          Taskinator::JobWorker.new(job_uuid).perform do |job, args|
+            job.perform(*args)
+          end
+        end
+      end
     end
   end
 end

data/lib/taskinator/queues/sidekiq.rb

@@ -11,7 +11,8 @@ module Taskinator
       def initialize(config={})
         config = {
           :process_queue => :default,
-          :task_queue => :default
+          :task_queue => :default,
+          :job_queue => :default
         }.merge(config)
 
         ProcessWorker.class_eval do
@@ -21,6 +22,10 @@ module Taskinator
         TaskWorker.class_eval do
           sidekiq_options :queue => config[:task_queue]
         end
+
+        JobWorker.class_eval do
+          sidekiq_options :queue => config[:job_queue]
+        end
       end
 
       def enqueue_process(process)
@@ -31,6 +36,14 @@ module Taskinator
         TaskWorker.perform_async(task.uuid)
       end
 
+      def enqueue_job(job)
+        # get the queue name
+        queue = job.job.get_sidekiq_options['queue']
+        JobWorker.get_sidekiq_options.merge!('queue' => queue) if queue
+
+        JobWorker.perform_async(job.uuid)
+      end
+
       class ProcessWorker
         include ::Sidekiq::Worker
 
@@ -46,6 +59,16 @@ module Taskinator
           Taskinator::TaskWorker.new(task_uuid).perform
         end
       end
+
+      class JobWorker
+        include ::Sidekiq::Worker
+
+        def perform(job_uuid)
+          Taskinator::JobWorker.new(job_uuid).perform do |job, args|
+            job.new.perform(*args)
+          end
+        end
+      end
     end
   end
 end

data/lib/taskinator/task.rb

@@ -8,6 +8,10 @@ module Taskinator
         Step.new(process, method, args, options)
       end
 
+      def define_job_task(process, job, args, options={})
+        Job.new(process, job, args, options)
+      end
+
       def define_sub_process_task(process, sub_process, options={})
         SubProcess.new(process, sub_process, options)
       end
@@ -108,7 +112,7 @@ module Taskinator
     end
 
     # a task which invokes the specified method on the definition
-    # the args must be intrinsic types, since they are serialized to JSON
+    # the args must be intrinsic types, since they are serialized to YAML
     class Step < Task
       attr_reader :definition
       attr_reader :method
@@ -148,6 +152,36 @@ module Taskinator
       end
     end
 
+    # a task which invokes the specified background job
+    # the args must be intrinsic types, since they are serialized to YAML
+    class Job < Task
+      attr_reader :definition
+      attr_reader :job
+      attr_reader :args
+
+      def initialize(process, job, args, options={})
+        super(process, options)
+        @definition = process.definition  # for convenience
+
+        raise ArgumentError, 'job' if job.nil?
+        raise ArgumentError, 'job' unless job.methods.include?(:perform) || job.instance_methods.include?(:perform)
+
+        @job = job
+        @args = args
+      end
+
+      def perform(&block)
+        yield(job, args)
+      end
+
+      def accept(visitor)
+        super
+        visitor.visit_type(:definition)
+        visitor.visit_type(:job)
+        visitor.visit_args(:args)
+      end
+    end
+
     # a task which delegates to another process
     class SubProcess < Task
       attr_reader :sub_process

data/lib/taskinator/version.rb

@@ -1,3 +1,3 @@
 module Taskinator
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/taskinator.rb

@@ -19,6 +19,7 @@ require 'taskinator/tasks'
 require 'taskinator/process'
 
 require 'taskinator/task_worker'
+require 'taskinator/job_worker'
 require 'taskinator/process_worker'
 
 require 'taskinator/executor'

data/spec/support/test_flow.rb

@@ -29,6 +29,8 @@ module TestFlow
 
     # invoke the specified sub process
     sub_process TestSubFlow
+
+    job TestWorkerJob
   end
 
   def error_task(*args)
@@ -65,4 +67,12 @@ module TestFlow
     end
   end
 
+  module TestWorkerJob
+    def self.perform(*args)
+    end
+
+    def perform(*args)
+    end
+  end
+
 end

data/spec/taskinator/definition/builder_spec.rb

@@ -123,11 +123,32 @@ describe Taskinator::Definition::Builder do
 
     it "fails if task method is not defined" do
       expect {
-        subject.task(:undefined_method)
+        subject.task(:undefined)
       }.to raise_error(NoMethodError)
     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, {})
+      subject.job(job)
+    end
+
+    it "fails if job module is nil" do
+      expect {
+        subject.job(nil)
+      }.to raise_error(ArgumentError)
+    end
+
+    # ok, fuzzy logic to determine what is ia job here!
+    it "fails if job module is not a job" do
+      expect {
+        subject.job(double('job', :methods => [], :instance_methods => []))
+      }.to raise_error(ArgumentError)
+    end
+  end
+
   describe "#sub_process" do
     let(:sub_definition) do
       Module.new() do

data/spec/taskinator/job_worker_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+
+describe Taskinator::JobWorker do
+
+  def mock_job(paused=false, cancelled=false)
+    double('job', :paused? => paused, :cancelled? => cancelled)
+  end
+
+  let(:uuid) { SecureRandom.uuid }
+
+  subject { Taskinator::JobWorker.new(uuid) }
+
+  it "should fetch the job" do
+    job = mock_job
+    expect(Taskinator::Task).to receive(:fetch).with(uuid) { job }
+    allow(job).to receive(:start!)
+    allow(job).to receive(:perform)
+    allow(job).to receive(:complete!)
+    subject.perform
+  end
+
+  it "should start the job" do
+    job = mock_job
+    allow(Taskinator::Task).to receive(:fetch).with(uuid) { job }
+    expect(job).to receive(:start!) { }
+    allow(job).to receive(:perform)
+    allow(job).to receive(:complete!)
+    subject.perform
+  end
+
+  it "should perform the job" do
+    job = mock_job(false, false)
+    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
+
+  it "should not start if paused" do
+    job = mock_job(true, false)
+    allow(Taskinator::Task).to receive(:fetch).with(uuid) { job }
+    expect(job).to_not receive(:start!)
+    subject.perform
+  end
+
+  it "should not start if cancelled" do
+    job = mock_job(false, true)
+    allow(Taskinator::Task).to receive(:fetch).with(uuid) { job }
+    expect(job).to_not receive(:start!)
+    subject.perform
+  end
+
+  it "should fail if job raises an error" do
+    job = mock_job
+    allow(Taskinator::Task).to receive(:fetch).with(uuid) { job }
+    allow(job).to receive(:start!) { raise NotImplementedError }
+    expect(job).to receive(:fail!).with(NotImplementedError)
+    subject.perform
+  end
+
+end

data/spec/taskinator/queues/delayed_job_spec.rb

@@ -9,28 +9,71 @@ describe Taskinator::Queues::DelayedJobAdapter do
 
   subject { adapter.new() }
 
-  it "enqueues processes" do
-    worker = adapter::ProcessWorker
-    expect {
-      subject.enqueue_process(double('process', :uuid => uuid))
-    }.to change(Delayed::Job.queue, :size).by(1)
-  end
+  describe "ProcessWorker" do
+    it "enqueues processes" do
+      worker = adapter::ProcessWorker
+      expect {
+        subject.enqueue_process(double('process', :uuid => uuid))
+      }.to change(Delayed::Job.queue, :size).by(1)
+    end
 
-  it "calls process worker" do
-    expect_any_instance_of(Taskinator::ProcessWorker).to receive(:perform)
-    adapter::ProcessWorker.new(uuid).perform
+    it "calls process worker" do
+      expect_any_instance_of(Taskinator::ProcessWorker).to receive(:perform)
+      adapter::ProcessWorker.new(uuid).perform
+    end
   end
 
-  it "enqueues tasks" do
-    worker = adapter::TaskWorker
-    expect {
-      subject.enqueue_process(double('task', :uuid => uuid))
-    }.to change(Delayed::Job.queue, :size).by(1)
-  end
+  describe "TaskWorker" do
+    it "enqueues tasks" do
+      worker = adapter::TaskWorker
+      expect {
+        subject.enqueue_process(double('task', :uuid => uuid))
+      }.to change(Delayed::Job.queue, :size).by(1)
+    end
 
-  it "calls task worker" do
-    expect_any_instance_of(Taskinator::TaskWorker).to receive(:perform)
-    adapter::TaskWorker.new(uuid).perform
+    it "calls task worker" do
+      expect_any_instance_of(Taskinator::TaskWorker).to receive(:perform)
+      adapter::TaskWorker.new(uuid).perform
+    end
   end
 
+  describe "JobWorker" do
+    it "enqueues jobs" do
+      worker = adapter::JobWorker
+
+      job = double('job')
+      job_task = double('job_task', :uuid => uuid, :job => job)
+
+      expect {
+        subject.enqueue_job(job_task)
+      }.to change(Delayed::Job.queue, :size).by(1)
+    end
+
+    it "calls job worker" do
+      expect_any_instance_of(Taskinator::JobWorker).to receive(:perform)
+      adapter::JobWorker.new(uuid).perform
+    end
+
+    let(:definition) do
+      Module.new() do
+        extend Taskinator::Definition
+      end
+    end
+
+    it "performs invocation on job" do
+      args = {: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

@@ -9,28 +9,67 @@ describe Taskinator::Queues::ResqueAdapter do
 
   subject { adapter.new() }
 
-  it "enqueues processes" do
-    worker = adapter::ProcessWorker
-    subject.enqueue_process(double('process', :uuid => uuid))
+  describe "ProcessWorker" do
+    it "enqueues processes" do
+      worker = adapter::ProcessWorker
+      subject.enqueue_process(double('process', :uuid => uuid))
 
-    expect(worker).to have_queued(uuid)
-  end
+      expect(worker).to have_queued(uuid)
+    end
 
-  it "calls process worker" do
-    expect_any_instance_of(Taskinator::ProcessWorker).to receive(:perform)
-    adapter::ProcessWorker.perform(uuid)
+    it "calls process worker" do
+      expect_any_instance_of(Taskinator::ProcessWorker).to receive(:perform)
+      adapter::ProcessWorker.perform(uuid)
+    end
   end
 
-  it "enqueues tasks" do
-    worker = adapter::TaskWorker
-    subject.enqueue_task(double('task', :uuid => uuid))
+  describe "TaskWorker" do
+    it "enqueues tasks" do
+      worker = adapter::TaskWorker
+      subject.enqueue_task(double('task', :uuid => uuid))
 
-    expect(worker).to have_queued(uuid)
-  end
+      expect(worker).to have_queued(uuid)
+    end
 
-  it "calls task worker" do
-    expect_any_instance_of(Taskinator::TaskWorker).to receive(:perform)
-    adapter::TaskWorker.perform(uuid)
+    it "calls task worker" do
+      expect_any_instance_of(Taskinator::TaskWorker).to receive(:perform)
+      adapter::TaskWorker.perform(uuid)
+    end
   end
 
+  describe "JobWorker" do
+    it "enqueues jobs" do
+      worker = adapter::JobWorker
+
+      job = double('job')
+      job_task = double('job_task', :uuid => uuid, :job => job)
+
+      subject.enqueue_job(job_task)
+      expect(worker).to have_queued(uuid)
+    end
+
+    it "calls job worker" do
+      expect_any_instance_of(Taskinator::JobWorker).to receive(:perform)
+      adapter::JobWorker.perform(uuid)
+    end
+
+    let(:definition) do
+      Module.new() do
+        extend Taskinator::Definition
+      end
+    end
+
+    it "performs invocation on job" do
+      args = {: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

@@ -9,28 +9,71 @@ describe Taskinator::Queues::SidekiqAdapter do
 
   subject { adapter.new() }
 
-  it "enqueues processes" do
-    worker = adapter::ProcessWorker
-    expect {
-      subject.enqueue_process(double('process', :uuid => uuid))
-    }.to change(worker.jobs, :size).by(1)
-  end
+  describe "ProcessWorker" do
+    it "enqueues processes" do
+      worker = adapter::ProcessWorker
+      expect {
+        subject.enqueue_process(double('process', :uuid => uuid))
+      }.to change(worker.jobs, :size).by(1)
+    end
 
-  it "calls process worker" do
-    expect_any_instance_of(Taskinator::ProcessWorker).to receive(:perform)
-    adapter::ProcessWorker.new().perform(uuid)
+    it "calls process worker" do
+      expect_any_instance_of(Taskinator::ProcessWorker).to receive(:perform)
+      adapter::ProcessWorker.new().perform(uuid)
+    end
   end
 
-  it "enqueues tasks" do
-    worker = adapter::TaskWorker
-    expect {
-      subject.enqueue_task(double('task', :uuid => uuid))
-    }.to change(worker.jobs, :size).by(1)
-  end
+  describe "TaskWorker" do
+    it "enqueues tasks" do
+      worker = adapter::TaskWorker
+      expect {
+        subject.enqueue_task(double('task', :uuid => uuid))
+      }.to change(worker.jobs, :size).by(1)
+    end
 
-  it "calls task worker" do
-    expect_any_instance_of(Taskinator::TaskWorker).to receive(:perform)
-    adapter::TaskWorker.new().perform(uuid)
+    it "calls task worker" do
+      expect_any_instance_of(Taskinator::TaskWorker).to receive(:perform)
+      adapter::TaskWorker.new().perform(uuid)
+    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)
+
+      expect {
+        subject.enqueue_job(job_task)
+      }.to change(worker.jobs, :size).by(1)
+    end
+
+    it "calls job worker" do
+      expect_any_instance_of(Taskinator::JobWorker).to receive(:perform)
+      adapter::JobWorker.new().perform(uuid)
+    end
+
+    let(:definition) do
+      Module.new() do
+        extend Taskinator::Definition
+      end
+    end
+
+    it "performs invocation on job" do
+      args = {: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/task_spec.rb

@@ -201,6 +201,51 @@ describe Taskinator::Task do
     end
   end
 
+  describe Taskinator::Task::Job do
+
+    module TestJob
+      def self.perform(*args)
+      end
+    end
+
+    it_should_behave_like "a task", Taskinator::Task::Job do
+      let(:process) { Class.new(Taskinator::Process).new(definition) }
+      let(:task) { Taskinator::Task.define_job_task(process, TestJob, {:a => 1, :b => 2}) }
+    end
+
+    let(:process) { Class.new(Taskinator::Process).new(definition) }
+    subject { Taskinator::Task.define_job_task(process, TestJob, {:a => 1, :b => 2}) }
+
+    describe "#perform" do
+      it {
+        block = SpecSupport::Block.new()
+        expect(block).to receive(:call).with(TestJob, {:a => 1, :b => 2})
+
+        subject.perform &block
+      }
+    end
+
+    describe "#accept" do
+      it {
+        expect(subject).to receive(:accept)
+        subject.save
+      }
+
+      it {
+        visitor = double('visitor')
+        expect(visitor).to receive(:visit_type).with(:definition)
+        expect(visitor).to receive(:visit_attribute).with(:uuid)
+        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_type).with(:job)
+        expect(visitor).to receive(:visit_args).with(:args)
+
+        subject.accept(visitor)
+      }
+    end
+  end
+
   describe Taskinator::Task::SubProcess do
     it_should_behave_like "a task", Taskinator::Task::SubProcess do
       let(:process) { Class.new(Taskinator::Process).new(definition) }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: taskinator
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - Chris Stefano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-02 00:00:00.000000000 Z
+date: 2014-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -230,6 +230,7 @@ files:
 - lib/taskinator/definition.rb
 - lib/taskinator/definition/builder.rb
 - lib/taskinator/executor.rb
+- lib/taskinator/job_worker.rb
 - lib/taskinator/logger.rb
 - lib/taskinator/persistence.rb
 - lib/taskinator/process.rb
@@ -258,6 +259,7 @@ files:
 - spec/taskinator/definition_spec.rb
 - spec/taskinator/executor_spec.rb
 - spec/taskinator/intermodal_spec.rb
+- spec/taskinator/job_worker_spec.rb
 - spec/taskinator/persistence_spec.rb
 - spec/taskinator/process_spec.rb
 - spec/taskinator/process_worker_spec.rb
@@ -309,6 +311,7 @@ test_files:
 - spec/taskinator/definition_spec.rb
 - spec/taskinator/executor_spec.rb
 - spec/taskinator/intermodal_spec.rb
+- spec/taskinator/job_worker_spec.rb
 - spec/taskinator/persistence_spec.rb
 - spec/taskinator/process_spec.rb
 - spec/taskinator/process_worker_spec.rb