asynchronic 0.1.0 → 0.2.0

data/spec/minitest_helper.rb

@@ -1,14 +1,15 @@
 require 'coverage_helper'
+require 'asynchronic'
 require 'minitest/autorun'
 require 'minitest/great_expectations'
 require 'turn'
-require 'asynchronic'
 require 'jobs'
 require 'expectations'
 
 Turn.config do |c|
   c.format = :pretty
   c.natural = true
+  c.ansi = true
 end
 
 class Module
@@ -26,4 +27,13 @@ class Minitest::Spec
     Asynchronic::DataStore::Redis.new.clear
     Asynchronic::QueueEngine::Ost.new.clear
   end
+end
+
+module Asynchronic::DataStore::Helper
+  def dump
+    puts 'DataStore:'
+    each do |k,v|
+      puts "#{k}: #{v}"
+    end
+  end
 end

data/spec/process/life_cycle_examples.rb

@@ -4,276 +4,290 @@ module LifeCycleExamples
 
   let(:queue) { env.default_queue }
 
-  def execute_work(queue)
-    env.load_process(queue.pop).execute
+  def create(type, params={})
+    env.create_process type, params
   end
 
-  def enqueue(process, data={})
-    process.enqueue(data).must_equal process.job.lookup.id
+  def execute(queue)
+    env.load_process(queue.pop).execute
   end
 
   it 'Basic' do
-    process = env.build_process BasicJob
+    process = create BasicJob, input: 1
 
     process.must_be_initialized
+    process.must_have_params input: 1
     queue.must_be_empty
 
-    enqueue process, input: 1
+    process.enqueue
 
     process.must_be_queued
-    process.must_have input: 1
     queue.must_enqueued process
 
-    execute_work queue
+    execute queue
 
     process.must_be_completed
-    process.must_have input: 1, output: 2
+    process.result.must_equal 2
     queue.must_be_empty
   end
 
   it 'Sequential' do
-    process = env.build_process SequentialJob
+    process = create SequentialJob, input: 50
 
     process.must_be_initialized
+    process.must_have_params input: 50
     queue.must_be_empty
 
-    enqueue process, input: 50
+    process.enqueue
 
     process.must_be_queued
-    process.processes.must_be_empty
-    process.must_have input: 50
     queue.must_enqueued process
 
-    execute_work queue
+    execute queue
 
     process.must_be_waiting
-    process.processes(SequentialJob::Step1).must_be_queued
-    process.processes(SequentialJob::Step2).must_be_pending
-    process.must_have input: 50
-    queue.must_enqueued process.processes(SequentialJob::Step1)
+    process[SequentialJob::Step1].must_be_queued
+    process[SequentialJob::Step1].must_have_params input: 50
+    process[SequentialJob::Step2].must_be_pending
+    process[SequentialJob::Step2].must_have_params input: 50
+    queue.must_enqueued process[SequentialJob::Step1]
 
-    execute_work queue
+    execute queue
 
     process.must_be_waiting
-    process.processes(SequentialJob::Step1).must_be_completed
-    process.processes(SequentialJob::Step2).must_be_queued
-    process.must_have input: 50, partial: 500
-    queue.must_enqueued process.processes(SequentialJob::Step2)
+    process[SequentialJob::Step1].must_be_completed
+    process[SequentialJob::Step1].result.must_equal 500
+    process[SequentialJob::Step2].must_be_queued
+    queue.must_enqueued process[SequentialJob::Step2]
 
-    execute_work queue
+    execute queue
 
     process.must_be_completed
-    process.processes(SequentialJob::Step1).must_be_completed
-    process.processes(SequentialJob::Step2).must_be_completed
-    process.must_have input: 50, partial: 500, output: 5
+    process.result.must_be_nil
+    process[SequentialJob::Step2].must_be_completed
+    process[SequentialJob::Step2].result.must_equal 5
     queue.must_be_empty
   end
 
   it 'Graph' do
-    process = env.build_process GraphJob
+    process = create GraphJob, input: 100
 
     process.must_be_initialized
+    process.must_have_params input: 100
     queue.must_be_empty
 
-    enqueue process, input: 100
+    process.enqueue
 
     process.must_be_queued
-    process.processes.must_be_empty
-    process.must_have input: 100
     queue.must_enqueued process
 
-    execute_work queue
+    execute queue
 
     process.must_be_waiting
-    process.processes(GraphJob::Sum).must_be_queued
-    process.processes(GraphJob::TenPercent).must_be_pending
-    process.processes(GraphJob::TwentyPercent).must_be_pending
-    process.processes(GraphJob::Total).must_be_pending
-    process.must_have input: 100
-    queue.must_enqueued process.processes(GraphJob::Sum)
+    process[GraphJob::Sum].must_be_queued
+    process[GraphJob::Sum].must_have_params input: 100
+    process[GraphJob::TenPercent].must_be_pending
+    process[GraphJob::TenPercent].must_have_params input: nil
+    process[GraphJob::TwentyPercent].must_be_pending
+    process[GraphJob::TwentyPercent].must_have_params input: nil
+    process[GraphJob::Total].must_be_pending
+    process[GraphJob::Total].must_have_params '10%' => nil, '20%' => nil
+    queue.must_enqueued process[GraphJob::Sum]
     
-    execute_work queue
+    execute queue
 
     process.must_be_waiting
-    process.processes(GraphJob::Sum).must_be_completed
-    process.processes(GraphJob::TenPercent).must_be_queued
-    process.processes(GraphJob::TwentyPercent).must_be_queued
-    process.processes(GraphJob::Total).must_be_pending
-    process.must_have input: 100, sum: 200
-    queue.must_enqueued [process.processes(GraphJob::TenPercent), process.processes(GraphJob::TwentyPercent)]
+    process[GraphJob::Sum].must_be_completed
+    process[GraphJob::Sum].result.must_equal 200
+    process[GraphJob::TenPercent].must_be_queued
+    process[GraphJob::TenPercent].must_have_params input: 200
+    process[GraphJob::TwentyPercent].must_be_queued
+    process[GraphJob::TwentyPercent].must_have_params input: 200
+    process[GraphJob::Total].must_be_pending
+    queue.must_enqueued [process[GraphJob::TenPercent], process[GraphJob::TwentyPercent]]
 
-    2.times { execute_work queue }
+    2.times { execute queue }
 
     process.must_be_waiting
-    process.processes(GraphJob::Sum).must_be_completed
-    process.processes(GraphJob::TenPercent).must_be_completed
-    process.processes(GraphJob::TwentyPercent).must_be_completed
-    process.processes(GraphJob::Total).must_be_queued
-    process.must_have input: 100, sum: 200, '10%' => 20, '20%' => 40
-    queue.must_enqueued process.processes(GraphJob::Total)
+    process[GraphJob::TenPercent].must_be_completed
+    process[GraphJob::TenPercent].result.must_equal 20
+    process[GraphJob::TwentyPercent].must_be_completed
+    process[GraphJob::TwentyPercent].result.must_equal 40
+    process[GraphJob::Total].must_be_queued
+    queue.must_enqueued process[GraphJob::Total]
 
-    execute_work queue
+    execute queue
 
     process.must_be_completed
-    process.processes(GraphJob::Sum).must_be_completed
-    process.processes(GraphJob::TenPercent).must_be_completed
-    process.processes(GraphJob::TwentyPercent).must_be_completed
-    process.processes(GraphJob::Total).must_be_completed
-    process.must_have input: 100, sum: 200, '10%' => 20, '20%' => 40, output: {'10%' => 20, '20%' => 40}
+    process.result.must_equal '10%' => 20, '20%' => 40
+    process[GraphJob::Total].must_be_completed
+    process[GraphJob::Total].result.must_equal '10%' => 20, '20%' => 40
     queue.must_be_empty
   end
 
   it 'Parallel' do
-    process = env.build_process ParallelJob
+    process = create ParallelJob, input: 10, times: 3
 
     process.must_be_initialized
+    process.must_have_params input: 10, times: 3
     queue.must_be_empty
 
-    enqueue process, input: 10, times: 3
+    process.enqueue
 
     process.must_be_queued
     process.processes.must_be_empty
-    process.must_have input: 10, times: 3
     queue.must_enqueued process
 
-    execute_work queue
+    execute queue
 
     process.must_be_waiting
-    process.processes.each { |p| p.must_be_queued }
-    process.must_have input: 10, times: 3
+    process.processes.count.must_equal 3
+    process.processes.each_with_index do |p,i|
+      p.must_be_queued
+      p.must_have_params input: 10, index: i
+    end
     queue.must_enqueued process.processes
 
-    3.times { execute_work queue }
+    3.times { execute queue }
 
     process.must_be_completed
-    process.processes.each { |p| p.must_be_completed }
-    hash = Hash[3.times.map { |i| ["key_#{i}", 10 * i] }]
-    process.must_have hash.merge(input: 10, times: 3)
+    process.result.must_equal 3
+    process.processes.each_with_index do |p,i|
+      p.must_be_completed
+      p.result.must_equal 10 * i
+    end
     queue.must_be_empty
   end
 
   it 'Nested' do
-    process = env.build_process NestedJob
+    process = create NestedJob, input: 4
 
     process.must_be_initialized
+    process.must_have_params input: 4
     queue.must_be_empty
 
-    enqueue process, input: 4
+    process.enqueue
 
     process.must_be_queued
     process.processes.must_be_empty
-    process.must_have input: 4
     queue.must_enqueued process
 
-    execute_work queue
+    execute queue
 
     process.must_be_waiting
-    process.processes(NestedJob::Level1).must_be_queued
-    process.processes(NestedJob::Level1).processes.must_be_empty
-    process.must_have input: 4
-    queue.must_enqueued process.processes(NestedJob::Level1)
+    process[NestedJob::Level1].must_be_queued
+    process[NestedJob::Level1].must_have_params input: 4
+    process[NestedJob::Level1].processes.must_be_empty
+    queue.must_enqueued process[NestedJob::Level1]
 
-    execute_work queue
+    execute queue
 
     process.must_be_waiting
-    process.processes(NestedJob::Level1).must_be_waiting
-    process.processes(NestedJob::Level1).processes(NestedJob::Level1::Level2).must_be_queued
-    process.must_have input: 5
-    queue.must_enqueued process.processes(NestedJob::Level1).processes(NestedJob::Level1::Level2)
+    process[NestedJob::Level1].must_be_waiting
+    process[NestedJob::Level1][NestedJob::Level1::Level2].must_be_queued
+    process[NestedJob::Level1][NestedJob::Level1::Level2].must_have_params input: 5
+    queue.must_enqueued process[NestedJob::Level1][NestedJob::Level1::Level2]
 
-    execute_work queue
+    execute queue
 
     process.must_be_completed
-    process.processes(NestedJob::Level1).must_be_completed
-    process.processes(NestedJob::Level1).processes(NestedJob::Level1::Level2).must_be_completed
-    process.must_have input: 5, output: 25
+    process.result.must_equal 25
+    process[NestedJob::Level1].must_be_completed
+    process[NestedJob::Level1].result.must_equal 25
+    process[NestedJob::Level1][NestedJob::Level1::Level2].must_be_completed
+    process[NestedJob::Level1][NestedJob::Level1::Level2].result.must_equal 25
     queue.must_be_empty
   end
 
-  it 'Dependency alias' do
-    process = env.build_process DependencyAliasJob
+  it 'Alias' do
+    process = create AliasJob
 
     process.must_be_initialized
     queue.must_be_empty
 
-    enqueue process
+    process.enqueue
 
     process.must_be_queued
     process.processes.must_be_empty
-    process.data.must_be_empty
     queue.must_enqueued process
 
-    execute_work queue
+    execute queue
 
     process.must_be_waiting
-    process.processes(:word_1).must_be_queued
-    process.processes(:word_2).must_be_pending
-    process.processes(:word_3).must_be_pending
-    process.data.must_be_empty
-    queue.must_enqueued process.processes(:word_1)
+    process[:word_1].must_be_queued
+    process[:word_1].must_have_params text: 'Take'
+    process[:word_2].must_be_pending
+    process[:word_2].must_have_params text: 'it', prefix: nil
+    process[:word_3].must_be_pending
+    process[:word_3].must_have_params text: 'easy', prefix: nil
+    queue.must_enqueued process[:word_1]
 
-    execute_work queue
+    execute queue
 
     process.must_be_waiting
-    process.processes(:word_1).must_be_completed
-    process.processes(:word_2).must_be_queued
-    process.processes(:word_3).must_be_pending
-    process.must_have text: 'Take'
-    queue.must_enqueued process.processes(:word_2)
+    process[:word_1].must_be_completed
+    process[:word_1].result.must_equal 'Take'
+    process[:word_2].must_be_queued
+    process[:word_2].must_have_params text: 'it', prefix: 'Take'
+    process[:word_3].must_be_pending
+    queue.must_enqueued process[:word_2]
 
-    execute_work queue
+    execute queue
 
     process.must_be_waiting
-    process.processes(:word_1).must_be_completed
-    process.processes(:word_2).must_be_completed
-    process.processes(:word_3).must_be_queued
-    process.must_have text: 'Take it'
-    queue.must_enqueued process.processes(:word_3)
+    process[:word_1].must_be_completed
+    process[:word_2].must_be_completed
+    process[:word_2].result.must_equal 'Take it'
+    process[:word_3].must_be_queued
+    process[:word_3].must_have_params text: 'easy', prefix: 'Take it'
+    queue.must_enqueued process[:word_3]
 
-    execute_work queue
+    execute queue
 
     process.must_be_completed
-    process.processes(:word_1).must_be_completed
-    process.processes(:word_2).must_be_completed
-    process.processes(:word_3).must_be_completed
-    process.must_have text: 'Take it easy'
+    process.result.must_equal 'Take it easy'
+    process[:word_1].must_be_completed
+    process[:word_2].must_be_completed
+    process[:word_3].must_be_completed
+    process[:word_3].result.must_equal 'Take it easy'
     queue.must_be_empty
   end
   
   it 'Custom queue' do
-    process = env.build_process CustomQueueJob
+    process = create CustomQueueJob, input: 'hello'
 
     process.must_be_initialized
-    
+    process.must_have_params input: 'hello'
+
     env.queue(:queue_1).must_be_empty
     env.queue(:queue_2).must_be_empty
     env.queue(:queue_3).must_be_empty
 
-    enqueue process, input: 'hello'
+    process.enqueue
 
     process.must_be_queued
     process.processes.must_be_empty
-    process.must_have input: 'hello'
     
     env.queue(:queue_1).must_enqueued process
     env.queue(:queue_2).must_be_empty
     env.queue(:queue_3).must_be_empty
 
-    execute_work env.queue(:queue_1)
+    execute env.queue(:queue_1)
 
     process.must_be_waiting
-    process.processes(CustomQueueJob::Reverse).must_be_queued
-    process.must_have input: 'hello'
+    process[CustomQueueJob::Reverse].must_be_queued
+    process[CustomQueueJob::Reverse].must_have_params input: 'hello'
     
     env.queue(:queue_1).must_be_empty
-    env.queue(:queue_2).must_enqueued process.processes(CustomQueueJob::Reverse)
+    env.queue(:queue_2).must_enqueued process[CustomQueueJob::Reverse]
     env.queue(:queue_3).must_be_empty
 
-    execute_work env.queue(:queue_2)
+    execute env.queue(:queue_2)
 
     process.must_be_completed
-    process.processes(CustomQueueJob::Reverse).must_be_completed
-    process.must_have input: 'hello', output: 'olleh'
+    process.result.must_equal 'olleh'
+    process[CustomQueueJob::Reverse].must_be_completed
+    process[CustomQueueJob::Reverse].result.must_equal 'olleh'
     
     env.queue(:queue_1).must_be_empty
     env.queue(:queue_2).must_be_empty
@@ -281,17 +295,17 @@ module LifeCycleExamples
   end
 
   it 'Exception' do
-    process = env.build_process ExceptionJob
+    process = create ExceptionJob
 
     process.must_be_initialized
     queue.must_be_empty
 
-    enqueue process
+    process.enqueue
 
     process.must_be_queued
     queue.must_enqueued process
 
-    execute_work queue
+    execute queue
 
     process.must_be_aborted
     process.error.must_be_instance_of Asynchronic::Error
@@ -299,31 +313,31 @@ module LifeCycleExamples
   end
 
   it 'Inner exception' do
-    process = env.build_process InnerExceptionJob
+    process = create InnerExceptionJob
 
     process.must_be_initialized
     queue.must_be_empty
 
-    enqueue process
+    process.enqueue
 
     process.must_be_queued
     queue.must_enqueued process
 
-    execute_work queue
+    execute queue
 
     process.must_be_waiting
-    process.processes(ExceptionJob).must_be_queued
-    queue.must_enqueued process.processes(ExceptionJob)
+    process[ExceptionJob].must_be_queued
+    queue.must_enqueued process[ExceptionJob]
 
-    execute_work queue
+    execute queue
 
     process.must_be_aborted
     process.error.must_be_instance_of Asynchronic::Error
     process.error.message.must_equal 'Error caused by ExceptionJob'
 
-    process.processes(ExceptionJob).must_be_aborted
-    process.processes(ExceptionJob).error.must_be_instance_of Asynchronic::Error
-    process.processes(ExceptionJob).error.message.must_equal 'Error for test'
+    process[ExceptionJob].must_be_aborted
+    process[ExceptionJob].error.must_be_instance_of Asynchronic::Error
+    process[ExceptionJob].error.message.must_equal 'Error for test'
   end
 
 end