asynchronic 0.0.1 → 0.1.0

data/spec/jobs.rb

@@ -1,58 +1,148 @@
-class Registry
-  extend Enumerable
+class BasicJob < Asynchronic::Job
+  define do
+    data[:output] = data[:input] + 1
+  end
+end
+
+
+class SequentialJob < Asynchronic::Job
+
+  define do
+    define_job Step1
+    define_job Step2, dependency: Step1
+  end
+
+  class Step1 < Asynchronic::Job
+    define do
+      data[:partial] = data[:input] * 10
+    end
+  end
+
+  class Step2 < Asynchronic::Job
+    define do
+      data[:output] = data[:partial] / 100
+    end
+  end
+
+end
+
+
+class GraphJob < Asynchronic::Job
+  
+  define do
+    define_job Sum
+    define_job TenPercent, dependency: Sum
+    define_job TwentyPercent, dependency: Sum
+    define_job Total, dependencies: [TenPercent, TwentyPercent]
+  end
+
+  class Sum < Asynchronic::Job
+    define do
+      data[:sum] = data[:input] + 100
+    end
+  end
+
+  class TenPercent < Asynchronic::Job
+    define do
+      data['10%'] = data[:sum] * 0.1
+    end
+  end
 
-  def self.add(arg)
-    Asynchronic.logger.debug('Asynchronic') { "Registry: #{arg}" }
-    elements << arg
-    arg
+  class TwentyPercent < Asynchronic::Job
+    define do
+      data['20%'] = data[:sum] * 0.2
+    end
   end
 
-  def self.clear
-    elements.clear
+  class Total < Asynchronic::Job
+    define do
+      data[:output] = {'10%' => data['10%'], '20%' => data['20%']}
+    end
   end
 
-  def self.each(&block)
-    elements.each(&block)
+end
+
+
+class ParallelJob < Asynchronic::Job
+  define do
+    data[:times].times do |i|
+      define_job Child, local: {index: i}
+    end
   end
 
-  def self.empty?
-    !any?
+  class Child < Asynchronic::Job
+    define do
+      data["key_#{index}"] = data[:input] * index
+    end
   end
+end
 
-  private
 
-  def self.elements
-    @elements ||= []
+class NestedJob < Asynchronic::Job
+  define do
+    define_job Level1
+  end
+
+  class Level1 < Asynchronic::Job
+    define do
+      data[:input] += 1
+      define_job Level2
+    end
+
+    class Level2 < Asynchronic::Job
+      define do
+        data[:output] = data[:input] ** 2
+      end
+    end
   end
 end
 
-class SingleStepJob
-  extend Asynchronic::Pipeline
-  step :step_name do
-    Registry.add :single_step_job
+
+class DependencyAliasJob < Asynchronic::Job
+  define do
+    define_job Write, local: {text: 'Take'}, alias: :word_1
+    define_job Write, local: {text: 'it'}, alias: :word_2, dependency: :word_1
+    define_job Write, local: {text: 'easy'}, alias: :word_3, dependency: :word_2
+  end
+
+  class Write < Asynchronic::Job
+    define do
+      data[:text] = "#{data[:text]} #{text}".strip
+    end
   end
 end
 
-class TwoStepsWithSpecificQueueJob
-  extend Asynchronic::Pipeline
-  queue :specific_queue
-  step :first do |ctx|
-    ctx[:value2] = ctx[:value1] / 2
-    Registry.add ctx[:value1] + 1
+
+class CustomQueueJob < Asynchronic::Job
+  queue :queue_1
+  define do
+    define_job Reverse, queue: :queue_2
   end
-  step :second do |ctx, input|
-    Registry.add input * ctx[:value2]
+
+  class Reverse < Asynchronic::Job
+    queue :queue_3
+    define do
+      data[:output] = data[:input].reverse
+    end
   end
 end
 
-class MultipleQueuesJob
-  extend Asynchronic::Pipeline
-  step :first_queue, queue: :queue1 do
-    Registry.add :first_queue
+
+class ExceptionJob < Asynchronic::Job
+  define do
+    raise 'Error for test'
   end
-  step :second_queue, queue: ->(ctx){ctx[:dynamic_queue]} do
-    Registry.add :second_queue
+end
+
+
+class InnerExceptionJob < Asynchronic::Job
+  define do
+    define_job ExceptionJob
   end
 end
 
 
+class WorkerJob < Asynchronic::Job
+  define do
+  end
+end

data/spec/minitest_helper.rb

@@ -1,31 +1,29 @@
 require 'coverage_helper'
 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
 end
 
-logger = Logger.new($stdout)
-logger.level = Logger::ERROR
-Asynchronic.logger = logger
-
-Asynchronic.connect_redis host: 'localhost', port: 6379
-
-Asynchronic.default_queue = 'asynchronic_test'
+class Module
+  include Minitest::Spec::DSL
+end
 
-Asynchronic.archiving_path = File.expand_path('../tmp', File.dirname(__FILE__))
+Asynchronic.logger.level = Logger::FATAL
 
-class MiniTest::Spec
-  
+class Minitest::Spec
   before do
-    Redis.current.flushdb
+    Asynchronic.restore_default_configuration
   end
 
-  def redis
-    Redis.current
+  after do
+    Asynchronic::DataStore::Redis.new.clear
+    Asynchronic::QueueEngine::Ost.new.clear
   end
-
 end

data/spec/process/life_cycle_examples.rb

@@ -0,0 +1,329 @@
+module LifeCycleExamples
+  
+  let(:env) { Asynchronic::Environment.new queue_engine, data_store }
+
+  let(:queue) { env.default_queue }
+
+  def execute_work(queue)
+    env.load_process(queue.pop).execute
+  end
+
+  def enqueue(process, data={})
+    process.enqueue(data).must_equal process.job.lookup.id
+  end
+
+  it 'Basic' do
+    process = env.build_process BasicJob
+
+    process.must_be_initialized
+    queue.must_be_empty
+
+    enqueue process, input: 1
+
+    process.must_be_queued
+    process.must_have input: 1
+    queue.must_enqueued process
+
+    execute_work queue
+
+    process.must_be_completed
+    process.must_have input: 1, output: 2
+    queue.must_be_empty
+  end
+
+  it 'Sequential' do
+    process = env.build_process SequentialJob
+
+    process.must_be_initialized
+    queue.must_be_empty
+
+    enqueue process, input: 50
+
+    process.must_be_queued
+    process.processes.must_be_empty
+    process.must_have input: 50
+    queue.must_enqueued process
+
+    execute_work 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)
+
+    execute_work 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)
+
+    execute_work 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
+    queue.must_be_empty
+  end
+
+  it 'Graph' do
+    process = env.build_process GraphJob
+
+    process.must_be_initialized
+    queue.must_be_empty
+
+    enqueue process, input: 100
+
+    process.must_be_queued
+    process.processes.must_be_empty
+    process.must_have input: 100
+    queue.must_enqueued process
+
+    execute_work 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)
+    
+    execute_work 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)]
+
+    2.times { execute_work 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)
+
+    execute_work 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}
+    queue.must_be_empty
+  end
+
+  it 'Parallel' do
+    process = env.build_process ParallelJob
+
+    process.must_be_initialized
+    queue.must_be_empty
+
+    enqueue process, input: 10, times: 3
+
+    process.must_be_queued
+    process.processes.must_be_empty
+    process.must_have input: 10, times: 3
+    queue.must_enqueued process
+
+    execute_work queue
+
+    process.must_be_waiting
+    process.processes.each { |p| p.must_be_queued }
+    process.must_have input: 10, times: 3
+    queue.must_enqueued process.processes
+
+    3.times { execute_work 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)
+    queue.must_be_empty
+  end
+
+  it 'Nested' do
+    process = env.build_process NestedJob
+
+    process.must_be_initialized
+    queue.must_be_empty
+
+    enqueue process, input: 4
+
+    process.must_be_queued
+    process.processes.must_be_empty
+    process.must_have input: 4
+    queue.must_enqueued process
+
+    execute_work 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)
+
+    execute_work 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)
+
+    execute_work 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
+    queue.must_be_empty
+  end
+
+  it 'Dependency alias' do
+    process = env.build_process DependencyAliasJob
+
+    process.must_be_initialized
+    queue.must_be_empty
+
+    enqueue process
+
+    process.must_be_queued
+    process.processes.must_be_empty
+    process.data.must_be_empty
+    queue.must_enqueued process
+
+    execute_work 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)
+
+    execute_work 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)
+
+    execute_work 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)
+
+    execute_work 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'
+    queue.must_be_empty
+  end
+  
+  it 'Custom queue' do
+    process = env.build_process CustomQueueJob
+
+    process.must_be_initialized
+    
+    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.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)
+
+    process.must_be_waiting
+    process.processes(CustomQueueJob::Reverse).must_be_queued
+    process.must_have input: 'hello'
+    
+    env.queue(:queue_1).must_be_empty
+    env.queue(:queue_2).must_enqueued process.processes(CustomQueueJob::Reverse)
+    env.queue(:queue_3).must_be_empty
+
+    execute_work env.queue(:queue_2)
+
+    process.must_be_completed
+    process.processes(CustomQueueJob::Reverse).must_be_completed
+    process.must_have input: 'hello', output: 'olleh'
+    
+    env.queue(:queue_1).must_be_empty
+    env.queue(:queue_2).must_be_empty
+    env.queue(:queue_3).must_be_empty
+  end
+
+  it 'Exception' do
+    process = env.build_process ExceptionJob
+
+    process.must_be_initialized
+    queue.must_be_empty
+
+    enqueue process
+
+    process.must_be_queued
+    queue.must_enqueued process
+
+    execute_work queue
+
+    process.must_be_aborted
+    process.error.must_be_instance_of Asynchronic::Error
+    process.error.message.must_equal 'Error for test'
+  end
+
+  it 'Inner exception' do
+    process = env.build_process InnerExceptionJob
+
+    process.must_be_initialized
+    queue.must_be_empty
+
+    enqueue process
+
+    process.must_be_queued
+    queue.must_enqueued process
+
+    execute_work queue
+
+    process.must_be_waiting
+    process.processes(ExceptionJob).must_be_queued
+    queue.must_enqueued process.processes(ExceptionJob)
+
+    execute_work 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'
+  end
+
+end

data/spec/process/life_cycle_in_memory_spec.rb

@@ -0,0 +1,11 @@
+require 'minitest_helper'
+require_relative './life_cycle_examples.rb'
+
+describe Asynchronic::Process, 'Life cycle - InMemory' do
+
+  let(:queue_engine) { Asynchronic::QueueEngine::InMemory.new }
+  let(:data_store) { Asynchronic::DataStore::InMemory.new }
+
+  include LifeCycleExamples
+
+end

data/spec/process/life_cycle_redis_spec.rb

@@ -0,0 +1,15 @@
+require 'minitest_helper'
+require_relative './life_cycle_examples.rb'
+
+describe Asynchronic::Process, 'Life cycle - Redis' do
+
+  let(:queue_engine) { Asynchronic::QueueEngine::Ost.new }
+  let(:data_store) { Asynchronic::DataStore::Redis.new }
+
+  before do
+    Redis.current.flushdb
+  end
+
+  include LifeCycleExamples
+
+end

data/spec/queue_engine/in_memory_spec.rb

@@ -0,0 +1,11 @@
+require 'minitest_helper'
+require_relative './queue_engine_examples'
+
+describe Asynchronic::QueueEngine::InMemory do
+
+  let(:engine) { Asynchronic::QueueEngine::InMemory.new }
+  let(:listener) { Asynchronic::QueueEngine::InMemory::Listener.new }
+
+  include QueueEngineExamples
+  
+end

data/spec/queue_engine/ost_spec.rb

@@ -0,0 +1,15 @@
+require 'minitest_helper'
+require_relative './queue_engine_examples'
+
+describe Asynchronic::QueueEngine::Ost do
+
+  let(:engine) { Asynchronic::QueueEngine::Ost.new }
+  let(:listener) { Asynchronic::QueueEngine::Ost::Listener.new }
+
+  before do
+    engine.clear
+  end
+  
+  include QueueEngineExamples
+  
+end

data/spec/queue_engine/queue_engine_examples.rb

@@ -0,0 +1,47 @@
+module QueueEngineExamples
+  
+  let(:queue) { engine[:test_queue] }
+
+  it 'Engine' do
+    engine.queues.must_be_empty
+    
+    queue = engine[:test_engine]
+    queue.must_be_instance_of engine.class.const_get(:Queue)
+    engine.queues.must_equal [:test_engine]
+    
+    engine[:test_engine].must_equal queue
+    
+    engine.clear
+    engine.queues.must_be_empty
+  end
+
+  it 'Queue (push/pop)' do
+    queue.must_be_empty
+    
+    queue.push 'msg_1'
+    queue.push 'msg_2'
+    
+    queue.size.must_equal 2
+    queue.to_a.must_equal %w(msg_1 msg_2)
+
+    queue.pop.must_equal 'msg_1'
+
+    queue.size.must_equal 1
+    queue.to_a.must_equal %w(msg_2)
+  end
+
+  it 'Listener' do
+    queue.push 'msg_1'
+    queue.push 'msg_2'
+
+    messages = []
+
+    listener.listen(queue) do |msg|
+      messages << msg
+      listener.stop if queue.empty?
+    end
+
+    messages.must_equal %w(msg_1 msg_2)
+  end
+
+end

data/spec/worker/in_memory_spec.rb

@@ -0,0 +1,11 @@
+require 'minitest_helper'
+require_relative './worker_examples'
+
+describe Asynchronic::Worker, 'InMemory' do
+
+  let(:queue_engine) { Asynchronic::QueueEngine::InMemory.new }
+  let(:data_store) { Asynchronic::DataStore::InMemory.new }
+
+  include WorkerExamples
+  
+end

data/spec/worker/redis_spec.rb

@@ -0,0 +1,16 @@
+require 'minitest_helper'
+require_relative './worker_examples'
+
+describe Asynchronic::Worker, 'Redis' do
+
+  let(:queue_engine) { Asynchronic::QueueEngine::Ost.new }
+  let(:data_store) { Asynchronic::DataStore::Redis.new }
+
+  before do
+    data_store.clear
+    queue_engine.clear
+  end
+
+  include WorkerExamples
+
+end