asynchronic 0.1.0 → 0.2.0

data/spec/data_store/in_memory_spec.rb

@@ -1,5 +1,6 @@
 require 'minitest_helper'
 require_relative './data_store_examples'
+require_relative './lazy_value_examples'
 
 describe Asynchronic::DataStore::InMemory do
 
@@ -7,4 +8,8 @@ describe Asynchronic::DataStore::InMemory do
 
   include DataStoreExamples
 
+  describe 'LazyValue' do
+    include LazyValueExamples
+  end
+
 end

data/spec/data_store/key_spec.rb

@@ -2,35 +2,59 @@ require 'minitest_helper'
 
 describe Asynchronic::DataStore::Key do
 
+  Key = Asynchronic::DataStore::Key
+
   it 'Return the namespace' do
-    key = Asynchronic::DataStore::Key.new('foo')
+    key = Key.new 'foo'
     key.must_equal 'foo'
   end
 
   it 'Prepend the namespace' do
-    key = Asynchronic::DataStore::Key.new('foo')
-    key['bar'].must_equal 'foo:bar'
+    key = Key.new 'foo'
+    key['bar'].must_equal 'foo|bar'
   end
 
   it 'Work in more than one level' do
-    key_1 = Asynchronic::DataStore::Key.new('foo')
-    key_2 = Asynchronic::DataStore::Key.new(key_1['bar'])
-    key_2['baz'].must_equal 'foo:bar:baz'
+    key_1 = Key.new 'foo'
+    key_2 = Key.new key_1['bar']
+    key_2['baz'].must_equal 'foo|bar|baz'
   end
 
   it 'Be chainable' do
-    key = Asynchronic::DataStore::Key.new('foo')
-    key['bar']['baz'].must_equal 'foo:bar:baz'
+    key = Key.new 'foo'
+    key['bar']['baz'].must_equal 'foo|bar|baz'
   end
 
   it 'Accept symbols' do
-    key = Asynchronic::DataStore::Key.new(:foo)
-    key[:bar].must_equal 'foo:bar'
+    key = Key.new :foo
+    key[:bar].must_equal 'foo|bar'
   end
 
   it 'Accept numbers' do
-    key = Asynchronic::DataStore::Key.new('foo')
-    key[3].must_equal 'foo:3'
+    key = Key.new 'foo'
+    key[3].must_equal 'foo|3'
+  end
+
+  it 'Split in sections' do
+    key = Key.new(:foo)[:bar][:buz]
+    key.sections.must_equal %w(foo bar buz)
+  end
+
+  it 'Detect nested sections' do
+    Key.new(:foo).wont_be :nested?
+    Key.new(:foo)[:bar].must_be :nested?
+  end
+
+  it 'Remove first sections' do
+    key = Key.new(:foo)[:bar][:buz]
+    key.remove_first.must_equal 'bar|buz'
+    key.remove_first(2).must_equal 'buz'
+  end
+
+  it 'Remove last sections' do
+    key = Key.new(:foo)[:bar][:buz]
+    key.remove_last.must_equal 'foo|bar'
+    key.remove_last(2).must_equal 'foo'
   end
   
 end

data/spec/data_store/lazy_value_examples.rb

@@ -0,0 +1,38 @@
+module LazyValueExamples
+
+  def lazy_value(key)
+    Asynchronic::DataStore::LazyValue.new data_store, key
+  end
+
+  it 'Get' do
+    value = lazy_value :key
+    value.must_be_nil
+    
+    data_store[:key] =  1
+    value.must_equal 1
+  end
+
+  it 'Reload' do
+    value = lazy_value :key
+
+    data_store[:key] =  1
+    value.must_equal 1
+
+    data_store[:key] =  2
+    value.must_equal 1
+    value.reload.must_equal 2
+  end
+
+  it 'Transparent proxy' do
+    value = lazy_value :key
+    data_store[:key] =  1
+    value.must_be_instance_of Fixnum
+    value.must_equal 1
+  end
+
+  it 'Inspect' do
+    value = lazy_value :key
+    value.inspect.must_match /#<Asynchronic::DataStore::LazyValue @data_store_class=.+ @data_store_connection=.+ @key=key>/
+  end
+
+end

data/spec/data_store/redis_spec.rb

@@ -1,5 +1,6 @@
 require 'minitest_helper'
 require_relative './data_store_examples'
+require_relative './lazy_value_examples'
 
 describe Asynchronic::DataStore::Redis do
 
@@ -11,4 +12,20 @@ describe Asynchronic::DataStore::Redis do
 
   include DataStoreExamples
 
+  it 'Safe deserialization' do
+    SampleClass = Class.new
+
+    data_store[:class] =  SampleClass
+    data_store[:instance] =  SampleClass.new
+
+    Object.send :remove_const, :SampleClass
+
+    data_store[:class].must_be_instance_of String
+    data_store[:instance].must_be_instance_of String
+  end
+
+  describe 'LazyValue' do
+    include LazyValueExamples
+  end
+
 end

data/spec/data_store/scoped_store_spec.rb

@@ -0,0 +1,60 @@
+require 'minitest_helper'
+
+describe Asynchronic::DataStore::ScopedStore do
+
+  let(:data_store) { MiniTest::Mock.new }
+  let(:scoped_store) { Asynchronic::DataStore::ScopedStore.new data_store, :scope }
+
+  it 'Get' do
+    data_store.expect(:[], 1, ['scope|key'])
+    scoped_store[:key].must_equal 1
+  end
+
+  it 'Set' do
+    data_store.expect(:[]=, nil, ['scope|key', 1])
+    scoped_store[:key] = 1
+  end
+
+  it 'Keys' do
+    data_store.expect(:keys, ['scope|a', 'scope|b'])
+    scoped_store.keys.must_equal ['a', 'b']
+  end
+
+  it 'Delete' do
+    data_store.expect(:delete, nil, ['scope|key'])
+    scoped_store.delete :key
+  end
+
+  it 'Each' do
+    data_store.expect(:keys, ['scope|a', 'scope|b'])
+    data_store.expect(:[], 1, ['scope|a'])
+    data_store.expect(:[], 2, ['scope|b'])
+
+    array = []
+    scoped_store.each { |k,v| array << "#{k} => #{v}" }
+    array.must_equal ['a => 1', 'b => 2']
+  end
+
+  it 'Merge' do
+    data_store.expect(:[]=, nil, ['scope|a', 1])
+    data_store.expect(:[]=, nil, ['scope|b', 2])
+    scoped_store.merge a: 1, b: 2
+  end
+
+  it 'Clear' do
+    data_store.expect(:keys, ['scope|key'])
+    data_store.expect(:delete, nil, ['scope|key'])
+    scoped_store.clear
+  end
+
+  it 'Scoped' do
+    data_store.expect(:[], 1, ['scope|nested|key'])
+    nested = scoped_store.scoped :nested
+    nested[:key].must_equal 1
+  end
+
+  it 'To string' do
+    scoped_store.to_s.must_match /#<Asynchronic::DataStore::ScopedStore @data_store=.+ @scope=scope>/
+  end
+
+end

data/spec/expectations.rb

@@ -1,14 +1,14 @@
 module MiniTest::Assertions
 
   def assert_enqueued(expected_processes, queue)
-    messages = Array(expected_processes).map { |p| p.job.lookup.id }
-    queue.to_a.sort.must_equal messages.sort, "Jobs #{Array(expected_processes).map{ |p| p.job.name }}"
+    messages = Array(expected_processes).map(&:id)
+    queue.to_a.sort.must_equal messages.sort, "Processes #{Array(expected_processes).map(&:id)}"
   end
 
-  def assert_have(expected_hash, process)
-    process.data.keys.count.must_equal expected_hash.keys.count, "Missing keys\nExpected keys: #{expected_hash.keys}\n  Actual keys: #{process.data.keys}"
+  def assert_have_params(expected_hash, process)
+    process.params.keys.count.must_equal expected_hash.keys.count, "Missing keys\nExpected keys: #{expected_hash.keys.map(&:to_s)}\n  Actual keys: #{process.params.keys}"
     expected_hash.each do |k,v|
-      process[k].must_equal v, "Key #{k}"
+      assert process.params[k] == v, "Different key '#{k}'\n  Actual: #{process.params[k]}\nExpected: #{v}"
     end
   end
 
@@ -17,7 +17,7 @@ module MiniTest::Assertions
     process.wont_be :finalized?
     
     process.processes.must_be_empty
-    process.data.must_be_empty
+    # process.data.must_be_empty
     process.error.must_be_nil
     
     process.created_at.must_be_instance_of Time
@@ -80,7 +80,7 @@ end
 
 Asynchronic::QueueEngine::InMemory::Queue.infect_an_assertion :assert_enqueued, :must_enqueued
 Asynchronic::QueueEngine::Ost::Queue.infect_an_assertion :assert_enqueued, :must_enqueued
-Asynchronic::Process.infect_an_assertion :assert_have, :must_have
+Asynchronic::Process.infect_an_assertion :assert_have_params, :must_have_params
 Asynchronic::Process.infect_an_assertion :assert_be_initialized, :must_be_initialized, :unary
 Asynchronic::Process.infect_an_assertion :assert_be_pending, :must_be_pending, :unary
 Asynchronic::Process.infect_an_assertion :assert_be_queued, :must_be_queued, :unary

data/spec/facade_spec.rb

@@ -26,35 +26,37 @@ describe Asynchronic, 'Facade' do
   it 'Environment' do
     Asynchronic.environment.tap do |env|
       env.queue_engine.must_equal Asynchronic.queue_engine
-      env.data_store.must_equal Asynchronic.data_store
+      env.data_store.connection.must_equal Asynchronic.data_store.scoped(:asynchronic).connection
     end
   end
 
   it 'Load process' do
-    process = Asynchronic.environment.build_process BasicJob
-    Asynchronic[process.pid].tap do |p|
-      p.pid.must_equal process.pid
-      p.job.must_equal process.job
+    process = Asynchronic.environment.create_process BasicJob
+    Asynchronic[process.id].tap do |p|
+      p.id.must_equal process.id
+      p.type.must_equal process.type
+      p.created_at.must_equal process.created_at
     end
   end
 
   it 'List processes' do
-    pids = 3.times.map do 
-      process = Asynchronic.environment.build_process SequentialJob
-      process.pid
+    ids = 3.times.map do 
+      process = Asynchronic.environment.create_process SequentialJob
+      process.id
     end
 
     Asynchronic.processes.count.must_equal 3
-    Asynchronic.processes.map(&:pid).each { |pid| pids.must_include pid }
+    3.times { |i| Asynchronic.processes[i].id == ids[i] }
   end
 
   it 'Enqueue' do
-    pid = BasicJob.enqueue input: 100
+    id = BasicJob.enqueue input: 100
     
     Asynchronic.environment.tap do |env|
-      env.default_queue.to_a.must_equal [pid]
-      env[pid].must_be_instance_of BasicJob
-      env.load_process(pid)[:input].must_equal 100
+      process = env.load_process id
+      process.type.must_equal BasicJob
+      process.params[:input].must_equal 100
+      env.default_queue.must_enqueued process
     end
   end
 

data/spec/jobs.rb

@@ -1,26 +1,30 @@
 class BasicJob < Asynchronic::Job
-  define do
-    data[:output] = data[:input] + 1
+  def call
+    params[:input] + 1
   end
 end
 
 
 class SequentialJob < Asynchronic::Job
 
-  define do
-    define_job Step1
-    define_job Step2, dependency: Step1
+  def call
+    async Step1, input: params[:input]
+    
+    async Step2, dependency: Step1, 
+                 input: params[:input]
+
+    nil
   end
 
   class Step1 < Asynchronic::Job
-    define do
-      data[:partial] = data[:input] * 10
+    def call
+      params[:input] * 10
     end
   end
 
   class Step2 < Asynchronic::Job
-    define do
-      data[:output] = data[:partial] / 100
+    def call
+      params[:input] / 10
     end
   end
 
@@ -29,34 +33,40 @@ 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]
+  def call
+    async Sum, input: params[:input]
+
+    async TenPercent, input: result(Sum)
+
+    async TwentyPercent, input: result(Sum)
+
+    async Total, '10%' => result(TenPercent),
+                 '20%' => result(TwentyPercent)
+
+    result Total
   end
 
   class Sum < Asynchronic::Job
-    define do
-      data[:sum] = data[:input] + 100
+    def call
+      params[:input] + 100
     end
   end
 
   class TenPercent < Asynchronic::Job
-    define do
-      data['10%'] = data[:sum] * 0.1
+    def call
+      params[:input] * 0.1
     end
   end
 
   class TwentyPercent < Asynchronic::Job
-    define do
-      data['20%'] = data[:sum] * 0.2
+    def call
+      params[:input] * 0.2
     end
   end
 
   class Total < Asynchronic::Job
-    define do
-      data[:output] = {'10%' => data['10%'], '20%' => data['20%']}
+    def call
+      {'10%' => params['10%'], '20%' => params['20%']}
     end
   end
 
@@ -64,50 +74,60 @@ end
 
 
 class ParallelJob < Asynchronic::Job
-  define do
-    data[:times].times do |i|
-      define_job Child, local: {index: i}
+  def call
+    params[:times].times do |i|
+      async Child, input: params[:input], index: i
     end
   end
 
   class Child < Asynchronic::Job
-    define do
-      data["key_#{index}"] = data[:input] * index
+    def call
+      params[:input] * params[:index]
     end
   end
 end
 
 
 class NestedJob < Asynchronic::Job
-  define do
-    define_job Level1
+  def call
+    async Level1, input: params[:input]
+    result Level1
   end
 
   class Level1 < Asynchronic::Job
-    define do
-      data[:input] += 1
-      define_job Level2
+    def call
+      async Level2, input: params[:input] + 1
+      result Level2
     end
 
     class Level2 < Asynchronic::Job
-      define do
-        data[:output] = data[:input] ** 2
+      def call
+        params[:input] ** 2
       end
     end
   end
 end
 
 
-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
+class AliasJob < Asynchronic::Job
+  def call
+    async Write, alias: :word_1,
+                 text: 'Take'
+    
+    async Write, alias: :word_2, 
+                 text: 'it', 
+                 prefix: result(:word_1)
+    
+    async Write, alias: :word_3, 
+                 text: 'easy', 
+                 prefix: result(:word_2)
+
+    result :word_3
   end
 
   class Write < Asynchronic::Job
-    define do
-      data[:text] = "#{data[:text]} #{text}".strip
+    def call
+      [params[:prefix], params[:text]].compact.join(' ')
     end
   end
 end
@@ -115,34 +135,35 @@ end
 
 class CustomQueueJob < Asynchronic::Job
   queue :queue_1
-  define do
-    define_job Reverse, queue: :queue_2
+  def call
+    async Reverse, queue: :queue_2, input: params[:input]
+    result Reverse
   end
 
   class Reverse < Asynchronic::Job
     queue :queue_3
-    define do
-      data[:output] = data[:input].reverse
+    def call
+      params[:input].reverse
     end
   end
 end
 
 
 class ExceptionJob < Asynchronic::Job
-  define do
+  def call
     raise 'Error for test'
   end
 end
 
 
 class InnerExceptionJob < Asynchronic::Job
-  define do
-    define_job ExceptionJob
+  def call
+    async ExceptionJob
   end
 end
 
 
 class WorkerJob < Asynchronic::Job
-  define do
+  def call
   end
 end