taskinator 0.0.17 → 0.0.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3936550148208b98dfaa2a841e97d322d14413b9
-  data.tar.gz: 92c8caa24c938962f8c5692dc5e45c9cfef012e2
+  metadata.gz: bd4b644d746cddfe50ed5d3c9d984bcd978d3fee
+  data.tar.gz: 45f8166dbd3f7f1b5e27d52c31c7e0384a433cc7
 SHA512:
-  metadata.gz: 21b0b016cbdec925215d9a621c60859b2c8ff69cee341e350e0962b557b6b1b27338df3cf5b84a24c7858221461571f5710e7a44af14531f8e7d1ac6e5ce676f
-  data.tar.gz: ca89c615cc65798746ccbdcfdb14eca8ac0d5617f24359f1402bd7001e802a4ee6ddbc21cd43fece92971e76b5d22e421dd46c12a43e6090a0f8ea21267284d1
+  metadata.gz: 34d036f6fedd66b61b73c6530716882a9b019a769431c719273e0b684e216838571cc3c49a7317292662f8dc41b1ff379c0c41480effb3f705ee0e8752a551de
+  data.tar.gz: 9fa6364a483ec5d361881b07f26e266ebebbfba07f1b44cb73470c5658e048448f38eece7d531cbb3785219253f83233b75e5589a05eedf06c1eadaeff74fff3

data/CHANGELOG.md

@@ -1,6 +1,12 @@
+v0.0.18 - 14 Jul 2015
+---
+Fixed issue with `Taskinator::Api::Processes#each` method, which was causing a Segmentation fault.
+Added statistics information.
+Improved specifications code coverage.
+
 v0.0.17 - 11 Jul 2015
 ---
-Fixed issue with `Task#each` method, which was causing a Segmentation fault.
+Fixed issue with `Taskinator::Task#each` method, which was causing a Segmentation fault.
 Added `define_sequential_process` and `define_concurrent_process` methods for defining processes.
 Added `ConsoleInstrumenter` instrumenter implementation.
 Required `resque` for console and rake tasks, to make debugging easier

data/Gemfile.lock

@@ -8,7 +8,7 @@ GIT
 PATH
   remote: .
   specs:
-    taskinator (0.0.17)
+    taskinator (0.0.18)
       connection_pool (>= 2.2.0)
       json (>= 1.8.2)
       redis (>= 3.2.1)

data/README.md

@@ -588,6 +588,24 @@ Taskinator.configure do |config|
 end
 ```
 
+### Instrumentation
+
+It is possible to instrument processes, tasks and jobs by providing an instrumeter such as `ActiveSupport::Notifications`.
+
+```ruby
+Taskinator.configure do |config|
+  config.instrumenter = ActiveSupport::Notifications
+end
+```
+
+Alternatively, you can use the built-in instrumenter for logging to the console for debugging:
+
+```ruby
+Taskinator.configure do |config|
+  config.instrumenter = Taskinator::ConsoleInstrumenter.new
+end
+```
+
 ## Notes
 
 The persistence logic is decoupled from the implementation, so it is possible to implement another backing store if required.

data/lib/taskinator/api.rb

@@ -3,7 +3,7 @@ module Taskinator
     class Processes
       include Enumerable
 
-      def each
+      def each(&block)
         return to_enum(__method__) unless block_given?
 
         instance_cache = {}

data/lib/taskinator/definition.rb

@@ -33,7 +33,9 @@ module Taskinator
                     Process.define_sequential_process_for(definition, options)
                   }
 
-      define_singleton_method :_create_process_ do |args, options={}|
+      define_singleton_method :_create_process_ do |*args|
+
+        options = args.last.is_a?(Hash) ? args.pop : {}
 
         # TODO: better validation of arguments
 
@@ -48,14 +50,25 @@ module Taskinator
           Builder.new(process, self, *args).instance_eval(&block)
         end
 
-        # instrument separately
-        Taskinator.instrumenter.instrument(:save_process, :uuid => process.uuid) do
-          process.save
-          # if this is a root process, then add it to the list
-          Persistence.add_process_to_list(process) unless options[:subprocess]
+        # only save "root processes"
+        unless options[:subprocess]
+
+          # instrument separately
+          Taskinator.instrumenter.instrument(:save_process, :uuid => process.uuid) do
+
+            # this will visit "sub processes" and persist them too
+            process.save
+
+            # add it to the list of "root processes"
+            Persistence.add_process_to_list(process)
+
+          end
+
         end
 
+        # this is the "root" process
         process
+
       end
     end
 
@@ -67,7 +80,7 @@ module Taskinator
     #
     def create_process(*args)
       assert_valid_process_module
-      _create_process_(args)
+      _create_process_(*args, :sub_process => false)
     end
 
     #
@@ -80,12 +93,12 @@ module Taskinator
       uuid = SecureRandom.uuid
       Taskinator.queue.enqueue_create_process(self, uuid, args)
 
-      Taskinator::Persistence::LazyLoader.new(Taskinator::Process, uuid)
+      Taskinator::Persistence::LazyLoader.new(Taskinator::Process, uuid, uuid)
     end
 
     def create_sub_process(*args)
       assert_valid_process_module
-      _create_process_(args, :subprocess => true)
+      _create_process_(*args, :subprocess => true)
     end
 
     private

data/lib/taskinator/executor.rb

@@ -10,7 +10,20 @@ module Taskinator
 
       # include the module into the eigen class, so it is only for this instance
       eigen = class << self; self; end
-      eigen.send :include, definition
+      eigen.send(:include, definition)
     end
+
+    def root_key
+      @root_key ||= task.root_key
+    end
+
+    def uuid
+      task.uuid
+    end
+
+    def options
+      task.options
+    end
+
   end
 end

data/lib/taskinator/persistence.rb

@@ -61,20 +61,36 @@ module Taskinator
     end
 
     module InstanceMethods
-      def key
-        self.class.key_for(self.uuid)
-      end
 
       def save
         Taskinator.redis do |conn|
           conn.multi do
-            RedisSerializationVisitor.new(conn, self).visit
-            conn.sadd "taskinator:#{self.class.base_key}", self.uuid
+            visitor = RedisSerializationVisitor.new(conn, self).visit
+            conn.hmset(
+              "taskinator:#{self.key}",
+              :tasks_count,     visitor.task_count,
+              :tasks_failed,    0,
+              :tasks_completed, 0,
+              :tasks_cancelled, 0,
+            )
             true
           end
         end
       end
 
+      # this is the persistence key
+      def key
+        @key ||= self.class.key_for(self.uuid)
+      end
+
+      # retrieves the root key associated
+      # with the process or task
+      def root_key
+        @root_key ||= Taskinator.redis do |conn|
+          conn.hget(self.key, :root_key)
+        end
+      end
+
       # retrieves the workflow state
       # this method is called from the workflow gem
       def load_workflow_state
@@ -116,6 +132,39 @@ module Taskinator
           [error_type, error_message, JSON.parse(error_backtrace)]
         end
       end
+
+      def tasks_count
+        @tasks_count ||= begin
+          Taskinator.redis do |conn|
+            conn.hget "taskinator:#{self.root_key}", :tasks_count
+          end.to_i
+        end
+      end
+
+      %w(
+        failed
+        cancelled
+        completed
+      ).each do |status|
+
+        define_method "count_#{status}" do
+          Taskinator.redis do |conn|
+            conn.hget "taskinator:#{self.root_key}", status
+          end.to_i
+        end
+
+        define_method "incr_#{status}" do
+          Taskinator.redis do |conn|
+            conn.hincrby "taskinator:#{self.root_key}", status, 1
+          end
+        end
+
+        define_method "percentage_#{status}" do
+          tasks_count > 0 ? (send("count_#{status}") / tasks_count.to_f) * 100.0 : 0.0
+        end
+
+      end
+
     end
 
     class RedisSerializationVisitor < Visitor::Base
@@ -126,38 +175,49 @@ module Taskinator
       # one roundtrip to the redis server
       #
 
-      def initialize(conn, instance, parent=nil)
-        @conn = conn
-        @instance = instance
-        @key = instance.key
-        # @parent = parent        # not using this yet
+      attr_reader :instance
+
+      def initialize(conn, instance, base_visitor=self)
+        @conn         = conn
+        @instance     = instance
+        @key          = instance.key
+        @root_key     = base_visitor.instance.key
+        @base_visitor = base_visitor
+        @task_count   = 0
       end
 
       # the starting point for serializing the instance
       def visit
         @hmset = []
         @hmset << @key
+
         @hmset += [:type, @instance.class.name]
 
         @instance.accept(self)
 
+        # add the root key, for easy access later!
+        @hmset += [:root_key, @root_key]
+
         # NB: splat args
         @conn.hmset(*@hmset)
+
+        self
       end
 
       def visit_process(attribute)
         process = @instance.send(attribute)
         if process
           @hmset += [attribute, process.uuid]
-          RedisSerializationVisitor.new(@conn, process, @instance).visit
+          RedisSerializationVisitor.new(@conn, process, @base_visitor).visit
         end
       end
 
       def visit_tasks(tasks)
-        @hmset += [:task_count, tasks.count]
+        @hmset += [:task_count, tasks.count]  # not used currently, but for informational purposes
         tasks.each do |task|
-          RedisSerializationVisitor.new(@conn, task, @instance).visit
+          RedisSerializationVisitor.new(@conn, task, @base_visitor).visit
           @conn.rpush "#{@key}:tasks", task.uuid
+          @base_visitor.incr_task_count unless task.is_a?(Task::SubProcess)
         end
       end
 
@@ -186,6 +246,14 @@ module Taskinator
         yaml = Taskinator::Persistence.serialize(values)
         @hmset += [attribute, yaml]
       end
+
+      def task_count
+        @task_count
+      end
+
+      def incr_task_count
+        @task_count += 1
+      end
     end
 
     class RedisDeserializationVisitor < Taskinator::Visitor::Base
@@ -293,8 +361,10 @@ module Taskinator
       def lazy_instance_for(base, uuid)
         Taskinator.redis do |conn|
           type = conn.hget(base.key_for(uuid), :type)
+          root_key = conn.hget(base.key_for(uuid), :root_key)
+
           klass = Kernel.const_get(type)
-          LazyLoader.new(klass, uuid, @instance_cache)
+          LazyLoader.new(klass, uuid, root_key, @instance_cache)
         end
       end
     end
@@ -310,13 +380,16 @@ module Taskinator
       # E.g. this is useful for tasks which refer to their parent processes
       #
 
-      def initialize(type, uuid, instance_cache={})
+      def initialize(type, uuid, root_key, instance_cache={})
         @type = type
         @uuid = uuid
+        @root_key = root_key
         @instance_cache = instance_cache
       end
 
-      attr_reader :uuid   # shadows the real method, but will be the same!
+      # shadows the real methods, but will be the same!
+      attr_reader :uuid
+      attr_reader :root_key
 
       # attempts to reload the actual process
       def reload
@@ -343,6 +416,8 @@ module Taskinator
           values.each {|key, value|
             values[key] = value.global_id if value.respond_to?(:global_id)
           }
+        elsif values.respond_to?(:global_id)
+          values = values.global_id
         end
         YAML.dump(values)
       end
@@ -357,6 +432,8 @@ module Taskinator
           values.each {|key, value|
             values[key] = value.find if value.respond_to?(:model_id) && value.respond_to?(:find)
           }
+        elsif values.respond_to?(:model_id) && values.respond_to?(:find)
+          values = values.find
         end
         values
       end

data/lib/taskinator/process.rb

@@ -122,7 +122,13 @@ module Taskinator
     include Persistence
 
     def enqueue
-      Taskinator.queue.enqueue_process(self)
+      # don't bother if there aren't any tasks!
+      if tasks.empty?
+        # simply complete the process...
+        complete!
+      else
+        Taskinator.queue.enqueue_process(self)
+      end
     end
 
     # callback for when the process has completed
@@ -164,7 +170,7 @@ module Taskinator
       end
 
       def inspect
-        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} state=:#{current_state.name}, tasks=[#{tasks.inspect}]>)
+        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} uuid="#{uuid}", state=:#{current_state.name}, tasks=[#{tasks.inspect}]>)
       end
     end
 
@@ -177,10 +183,10 @@ module Taskinator
       end
 
       def start
-        if tasks.any?
-          tasks.each(&:enqueue!)
-        else
+        if tasks.empty?
           complete! # weren't any tasks to start with
+        else
+          tasks.each(&:enqueue!)
         end
       end
 
@@ -205,7 +211,7 @@ module Taskinator
       end
 
       def inspect
-        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} state=:#{current_state.name}, complete_on=:#{complete_on}, tasks=[#{tasks.inspect}]>)
+        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} uuid="#{uuid}", state=:#{current_state.name}, complete_on=:#{complete_on}, tasks=[#{tasks.inspect}]>)
       end
     end
 

data/lib/taskinator/task.rb

@@ -105,16 +105,23 @@ module Taskinator
 
     # callback for when the task has completed
     def on_completed_entry(*args)
+      self.incr_completed
       # notify the process that this task has completed
       process.task_completed(self)
     end
 
     # callback for when the task has failed
     def on_failed_entry(*args)
+      self.incr_failed
       # notify the process that this task has failed
       process.task_failed(self, args.last)
     end
 
+    # callback for when the task has cancelled
+    def on_cancelled_entry(*args)
+      self.incr_cancelled
+    end
+
     # helper method, delegating to process
     def paused?
       process.paused?
@@ -144,7 +151,7 @@ module Taskinator
       end
 
       def executor
-        @executor ||= Taskinator::Executor.new(@definition)
+        @executor ||= Taskinator::Executor.new(@definition, self)
       end
 
       def start
@@ -168,7 +175,7 @@ module Taskinator
       end
 
       def inspect
-        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} method=:#{method}, state=:#{current_state.name}>)
+        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} uuid="#{uuid}", method=:#{method}, args=#{args}, state=:#{current_state.name}>)
       end
     end
 
@@ -214,7 +221,7 @@ module Taskinator
       end
 
       def inspect
-        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} job=#{job}, state=:#{current_state.name}>)
+        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} uuid="#{uuid}", job=#{job}, args=#{args}, state=:#{current_state.name}>)
       end
     end
 
@@ -247,7 +254,7 @@ module Taskinator
       end
 
       def inspect
-        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} sub_process=#{sub_process.inspect}, state=:#{current_state.name}>)
+        %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} uuid="#{uuid}", sub_process=#{sub_process.inspect}, state=:#{current_state.name}>)
       end
     end
 

data/lib/taskinator/tasks.rb

@@ -42,7 +42,7 @@ module Taskinator
     end
 
     def inspect
-      %(#<#{self.class.name}:0x#{self.__id__.to_s(16)} tasks=[#{collect(&:inspect).join(', ')}]>)
+      %([#{collect(&:inspect).join(', ')}])
     end
 
   end

data/lib/taskinator/version.rb

@@ -1,3 +1,3 @@
 module Taskinator
-  VERSION = "0.0.17"
+  VERSION = "0.0.18"
 end

data/lib/taskinator/visitor.rb

@@ -21,6 +21,10 @@ module Taskinator
 
       def visit_args(attribute)
       end
+
+      def task_count
+        # return the total count of all tasks
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -76,3 +76,13 @@ end
 
 # require examples, must happen after configure
 Dir[File.expand_path("../examples/**/*.rb", __FILE__)].each {|f| require f }
+
+def recursively_enumerate_tasks(tasks, &block)
+  tasks.each do |task|
+    if task.is_a?(Taskinator::Task::SubProcess)
+      recursively_enumerate_tasks(task.sub_process.tasks, &block)
+    else
+      yield task
+    end
+  end
+end

data/spec/support/mock_model.rb

@@ -0,0 +1,18 @@
+class MockModel
+
+  attr_reader :model_id
+  attr_reader :model_type
+
+  def initialize
+    @model_id = 1
+    @model_type = 'TypeX'
+  end
+
+  def global_id
+    { :model_id => model_id, :model_type => model_type }
+  end
+
+  def find
+  end
+
+end

data/spec/support/test_flows.rb

@@ -0,0 +1,86 @@
+module TestFlows
+
+  module Worker
+    def self.perform(*args)
+    end
+
+    def perform(*args)
+    end
+  end
+
+  module Support
+
+    def iterator(task_count)
+      task_count.times do |i|
+        yield i
+      end
+    end
+
+    def do_task(*args)
+    end
+
+  end
+
+  module Task
+    extend Taskinator::Definition
+    include Support
+
+    define_process :task_count do
+      for_each :iterator do
+        task :do_task
+      end
+    end
+
+  end
+
+  module Job
+    extend Taskinator::Definition
+    include Support
+
+    define_process :task_count do
+      for_each :iterator do
+        job Worker
+      end
+    end
+
+  end
+
+  module SubProcess
+    extend Taskinator::Definition
+    include Support
+
+    define_process :task_count do
+      sub_process Task
+    end
+
+  end
+
+  module Sequential
+    extend Taskinator::Definition
+    include Support
+
+    define_process :task_count do
+      sequential do
+        for_each :iterator do
+          task :do_task
+        end
+      end
+    end
+
+  end
+
+  module Concurrent
+    extend Taskinator::Definition
+    include Support
+
+    define_process :task_count do
+      concurrent do
+        for_each :iterator do
+          task :do_task
+        end
+      end
+    end
+
+  end
+
+end

data/spec/taskinator/definition/builder_spec.rb

@@ -91,10 +91,9 @@ describe Taskinator::Definition::Builder do
   describe "#for_each" do
     it "creates tasks for each returned item" do
       # the definition is mixed into the eigen class of Executor
-      # HACK: replace the internal executor instance
 
+      # HACK: replace the internal executor instance
       executor = Taskinator::Executor.new(definition)
-
       subject.instance_eval do
         @executor = executor
       end

data/spec/taskinator/definition_spec.rb

@@ -18,7 +18,6 @@ describe Taskinator::Definition do
 
   describe "#define_process" do
     it "should define a #create_process method" do
-      subject.define_process
       expect(subject).to respond_to(:create_process)
     end
 
@@ -34,6 +33,60 @@ describe Taskinator::Definition do
         subject.define_process
       }.to raise_error(Taskinator::Definition::ProcessAlreadyDefinedError)
     end
+
+    it "should create a sequential process" do
+      subject.define_process {}
+      expect(subject.create_process).to be_a(Taskinator::Process::Sequential)
+    end
+  end
+
+  describe "#define_sequential_process" do
+    it "should define a #define_sequential_process method" do
+      expect(subject).to respond_to(:define_sequential_process)
+    end
+
+    it "should not invoke the given block" do
+      block = SpecSupport::Block.new
+      expect(block).to_not receive(:call)
+      subject.define_sequential_process(&block)
+    end
+
+    it "should raise ProcessAlreadyDefinedError error if already defined" do
+      subject.define_sequential_process
+      expect {
+        subject.define_sequential_process
+      }.to raise_error(Taskinator::Definition::ProcessAlreadyDefinedError)
+    end
+
+    it "should create a sequential process" do
+      subject.define_sequential_process {}
+      expect(subject.create_process).to be_a(Taskinator::Process::Sequential)
+    end
+  end
+
+  describe "#define_concurrent_process" do
+    it "should define a #define_concurrent_process method" do
+      subject.define_concurrent_process
+      expect(subject).to respond_to(:define_concurrent_process)
+    end
+
+    it "should not invoke the given block" do
+      block = SpecSupport::Block.new
+      expect(block).to_not receive(:call)
+      subject.define_concurrent_process(&block)
+    end
+
+    it "should raise ProcessAlreadyDefinedError error if already defined" do
+      subject.define_concurrent_process
+      expect {
+        subject.define_concurrent_process
+      }.to raise_error(Taskinator::Definition::ProcessAlreadyDefinedError)
+    end
+
+    it "should create a concurrent process" do
+      subject.define_concurrent_process {}
+      expect(subject.create_process).to be_a(Taskinator::Process::Concurrent)
+    end
   end
 
   describe "#create_process" do

data/spec/taskinator/persistence_spec.rb

@@ -87,6 +87,125 @@ describe Taskinator::Persistence, :redis => true do
     end
   end
 
+  describe "serialization helpers" do
+    subject { Taskinator::Persistence }
+
+    describe "#serialize" do
+      describe "Array" do
+        it {
+          expect(subject.serialize([])).to eq(YAML.dump([]))
+        }
+
+        it {
+          expect(subject.serialize([1])).to eq(YAML.dump([1]))
+        }
+
+        it {
+          expect(subject.serialize(["string"])).to eq(YAML.dump(["string"]))
+        }
+
+        it {
+          expect(subject.serialize([MockModel.new])).to eq(YAML.dump([{:model_id => 1, :model_type => 'TypeX'}]))
+        }
+      end
+
+      describe "Hash" do
+        it {
+          expect(subject.serialize({:foo => :bar})).to eq(YAML.dump({:foo => :bar}))
+        }
+
+        it {
+          expect(subject.serialize({:foo => 1})).to eq(YAML.dump({:foo => 1}))
+        }
+
+        it {
+          expect(subject.serialize({:foo => "string"})).to eq(YAML.dump({:foo => "string"}))
+        }
+
+        it {
+          expect(subject.serialize({:foo => MockModel.new})).to eq(YAML.dump({:foo => {:model_id => 1, :model_type => 'TypeX'}}))
+        }
+      end
+
+      describe "Object" do
+        it {
+          expect(subject.serialize(:foo)).to eq(YAML.dump(:foo))
+        }
+
+        it {
+          expect(subject.serialize(1)).to eq(YAML.dump(1))
+        }
+
+        it {
+          expect(subject.serialize("string")).to eq(YAML.dump("string"))
+        }
+
+        it {
+          expect(subject.serialize(MockModel.new)).to eq(YAML.dump({:model_id => 1, :model_type => 'TypeX'}))
+        }
+      end
+    end
+
+    describe "#deserialize" do
+      describe "Array" do
+        it {
+          expect(subject.deserialize(YAML.dump([]))).to eq([])
+        }
+
+        it {
+          expect(subject.deserialize(YAML.dump([1]))).to eq([1])
+        }
+
+        it {
+          expect(subject.deserialize(YAML.dump(["string"]))).to eq(["string"])
+        }
+
+        it {
+          expect_any_instance_of(MockModel).to receive(:find)
+          subject.deserialize(YAML.dump([MockModel.new]))
+        }
+      end
+
+      describe "Hash" do
+        it {
+          expect(subject.deserialize(YAML.dump({:foo => :bar}))).to eq({:foo => :bar})
+        }
+
+        it {
+          expect(subject.deserialize(YAML.dump({:foo => 1}))).to eq({:foo => 1})
+        }
+
+        it {
+          expect(subject.deserialize(YAML.dump({:foo => "string"}))).to eq({:foo => "string"})
+        }
+
+        it {
+          expect_any_instance_of(MockModel).to receive(:find)
+          subject.deserialize(YAML.dump({:foo => MockModel.new}))
+        }
+      end
+
+      describe "Object" do
+        it {
+          expect(subject.deserialize(YAML.dump(:foo))).to eq(:foo)
+        }
+
+        it {
+          expect(subject.deserialize(YAML.dump(1))).to eq(1)
+        }
+
+        it {
+          expect(subject.deserialize(YAML.dump("string"))).to eq("string")
+        }
+
+        it {
+          expect_any_instance_of(MockModel).to receive(:find)
+          subject.deserialize(YAML.dump(MockModel.new))
+        }
+      end
+    end
+  end
+
   describe "instance methods" do
     subject {
       klass = Class.new do

data/spec/taskinator/process_spec.rb

@@ -63,19 +63,31 @@ describe Taskinator::Process do
     describe "workflow" do
       describe "#enqueue!" do
         it { expect(subject).to respond_to(:enqueue!) }
+
         it {
           expect(subject).to receive(:enqueue)
           subject.enqueue!
         }
+
         it {
+          expect(subject.current_state.name).to eq(:initial)
           subject.enqueue!
           expect(subject.current_state.name).to eq(:enqueued)
         }
-        it {
+
+        it "should not enqueue if there aren't any tasks" do
+          expect {
+            subject.enqueue!
+          }.to change { Taskinator.queue.processes.length }.by(0)
+        end
+
+        it "should enqueue if there are tasks" do
+          allow(subject).to receive(:tasks).and_return([Object.new])
+
           expect {
             subject.enqueue!
           }.to change { Taskinator.queue.processes.length }.by(1)
-        }
+        end
       end
 
       describe "#start!" do
@@ -85,6 +97,7 @@ describe Taskinator::Process do
           subject.start!
         }
         it {
+          expect(subject.current_state.name).to eq(:initial)
           subject.start!
           expect(subject.current_state.name).to eq(:processing)
         }
@@ -97,6 +110,7 @@ describe Taskinator::Process do
           subject.cancel!
         }
         it {
+          expect(subject.current_state.name).to eq(:initial)
           subject.cancel!
           expect(subject.current_state.name).to eq(:cancelled)
         }
@@ -205,6 +219,13 @@ describe Taskinator::Process do
     describe "#reload" do
       it { expect(subject.reload).to_not be }
     end
+
+    describe "#tasks_count" do
+      it {
+        expect(subject.tasks_count).to eq(0)
+      }
+    end
+
   end
 
   describe Taskinator::Process::Sequential do
@@ -318,6 +339,10 @@ describe Taskinator::Process do
         subject.accept(visitor)
       }
     end
+
+    describe "#inspect" do
+      it { expect(subject.inspect).to_not be_nil }
+    end
   end
 
   describe Taskinator::Process::Concurrent do
@@ -463,6 +488,10 @@ describe Taskinator::Process do
         subject.accept(visitor)
       }
     end
+
+    describe "#inspect" do
+      it { expect(subject.inspect).to_not be_nil }
+    end
   end
 
 end

data/spec/taskinator/task_spec.rb

@@ -161,6 +161,12 @@ describe Taskinator::Task do
     describe "#reload" do
       it { expect(subject.reload).to_not be }
     end
+
+    describe "#tasks_count" do
+      it {
+        expect(subject.tasks_count).to eq(0)
+      }
+    end
   end
 
   describe Taskinator::Task::Step do
@@ -197,6 +203,34 @@ describe Taskinator::Task do
         subject.start!
       end
 
+      it "provides execution context" do
+        executor = Taskinator::Executor.new(definition, subject)
+
+        method = subject.method
+
+        executor.class_eval do
+          define_method method do |*args|
+            # this method executes in the scope of the executor
+            # store the context in an instance variable
+            @exec_context = self
+          end
+        end
+
+        # replace the internal executor instance for the task
+        # with this one, so we can hook into the methods
+        subject.instance_eval { @executor = executor }
+
+        # task start will invoke the method on the executor
+        subject.start!
+
+        # extract the instance variable
+        exec_context = executor.instance_eval { @exec_context }
+
+        expect(exec_context).to eq(executor)
+        expect(exec_context.uuid).to eq(subject.uuid)
+        expect(exec_context.options).to eq(subject.options)
+      end
+
       it "is instrumented" do
         allow(subject.executor).to receive(subject.method)
 
@@ -239,6 +273,10 @@ describe Taskinator::Task do
         subject.accept(visitor)
       }
     end
+
+    describe "#inspect" do
+      it { expect(subject.inspect).to_not be_nil }
+    end
   end
 
   describe Taskinator::Task::Job do
@@ -313,6 +351,10 @@ describe Taskinator::Task do
         subject.accept(visitor)
       }
     end
+
+    describe "#inspect" do
+      it { expect(subject.inspect).to_not be_nil }
+    end
   end
 
   describe Taskinator::Task::SubProcess do
@@ -384,6 +426,10 @@ describe Taskinator::Task do
         subject.accept(visitor)
       }
     end
+
+    describe "#inspect" do
+      it { expect(subject.inspect).to_not be_nil }
+    end
   end
 
 end

data/spec/taskinator/test_flows_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+describe TestFlows do
+
+  [
+    TestFlows::Task,
+    TestFlows::Job,
+    TestFlows::SubProcess,
+    TestFlows::Sequential,
+    TestFlows::Sequential
+  ].each do |definition|
+
+    describe definition.name do
+
+      it "should have one task" do
+        process = definition.create_process(1)
+        expect(process.tasks_count).to eq(1)
+      end
+
+      it "should have 3 tasks" do
+        process = definition.create_process(3)
+        expect(process.tasks_count).to eq(3)
+      end
+
+      %w(
+        failed
+        cancelled
+        completed
+      ).each do |status|
+
+        describe "count_#{status}" do
+          it {
+            process = definition.create_process(1)
+            expect(process.send(:"count_#{status}")).to eq(0)
+          }
+
+          it {
+            process = definition.create_process(2)
+            expect(process.send(:"count_#{status}")).to eq(0)
+          }
+        end
+
+        describe "incr_#{status}" do
+          it {
+            process = definition.create_process(1)
+            process.send(:"incr_#{status}")
+            expect(process.send(:"count_#{status}")).to eq(1)
+          }
+
+          it {
+            process = definition.create_process(4)
+            4.times do |i|
+              process.send(:"incr_#{status}")
+              expect(process.send(:"count_#{status}")).to eq(i + 1)
+            end
+          }
+
+          it "should increment completed count" do
+            process = definition.create_process(10)
+            recursively_enumerate_tasks(process.tasks) do |task|
+              task.send(:"incr_#{status}")
+            end
+            expect(process.send(:"count_#{status}")).to eq(10)
+          end
+        end
+
+        describe "percentage_#{status}" do
+          it {
+            process = definition.create_process(1)
+            expect(process.send(:"percentage_#{status}")).to eq(0.0)
+          }
+
+          it {
+            process = definition.create_process(4)
+            expect(process.send(:"percentage_#{status}")).to eq(0.0)
+
+            count = 4
+            count.times do |i|
+              process.send(:"incr_#{status}")
+              expect(process.send(:"percentage_#{status}")).to eq( ((i + 1.0) / count) * 100.0 )
+            end
+          }
+        end
+
+      end
+    end
+  end
+end

data/spec/taskinator/visitor_spec.rb

@@ -9,5 +9,6 @@ describe Taskinator::Visitor::Base do
   it { respond_to(:visit_task_reference) }
   it { respond_to(:visit_type) }
   it { respond_to(:visit_args) }
+  it { respond_to(:task_count) }
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: taskinator
 version: !ruby/object:Gem::Version
-  version: 0.0.17
+  version: 0.0.18
 platform: ruby
 authors:
 - Chris Stefano
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-11 00:00:00.000000000 Z
+date: 2015-07-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -287,10 +287,12 @@ files:
 - spec/spec_helper.rb
 - spec/support/delayed_job.rb
 - spec/support/mock_definition.rb
+- spec/support/mock_model.rb
 - spec/support/sidekiq_matchers.rb
 - spec/support/spec_support.rb
 - spec/support/test_definition.rb
 - spec/support/test_flow.rb
+- spec/support/test_flows.rb
 - spec/support/test_process.rb
 - spec/support/test_queue.rb
 - spec/support/test_task.rb
@@ -312,6 +314,7 @@ files:
 - spec/taskinator/task_worker_spec.rb
 - spec/taskinator/taskinator_spec.rb
 - spec/taskinator/tasks_spec.rb
+- spec/taskinator/test_flows_spec.rb
 - spec/taskinator/visitor_spec.rb
 - taskinator.gemspec
 - tasks_workflow.png
@@ -347,10 +350,12 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/delayed_job.rb
 - spec/support/mock_definition.rb
+- spec/support/mock_model.rb
 - spec/support/sidekiq_matchers.rb
 - spec/support/spec_support.rb
 - spec/support/test_definition.rb
 - spec/support/test_flow.rb
+- spec/support/test_flows.rb
 - spec/support/test_process.rb
 - spec/support/test_queue.rb
 - spec/support/test_task.rb
@@ -372,4 +377,5 @@ test_files:
 - spec/taskinator/task_worker_spec.rb
 - spec/taskinator/taskinator_spec.rb
 - spec/taskinator/tasks_spec.rb
+- spec/taskinator/test_flows_spec.rb
 - spec/taskinator/visitor_spec.rb