resque_jobs_tree 0.3.4 → 0.4.0

data/test/resources_serializer_test.rb

@@ -5,12 +5,12 @@ class ResourcesSerializerTest < MiniTest::Unit::TestCase
   def test_serialization_deserialization
     model = Model.new 42
     input = [model, :pdf, [1,2]]
-    serialized_input = ResqueJobsTree::ResourcesSerializer.to_args(input)
-    result = [['Model', model.id], :pdf, [1,2]]
-    assert_equal serialized_input, result
-    deserialized = ResqueJobsTree::ResourcesSerializer.
-      to_resources(serialized_input)
-    assert_equal deserialized, [Model.new(42), :pdf, [1,2]]
+    serialized_input = ResqueJobsTree::ResourcesSerializer.argumentize(input)
+
+    assert_equal [['Model', model.id], :pdf, [1,2]], serialized_input
+
+    assert_equal [Model.new(42), :pdf, [1,2]],
+      ResqueJobsTree::ResourcesSerializer.instancize(serialized_input)
   end
   
 end

data/test/storage_node_test.rb

@@ -0,0 +1,117 @@
+require 'test_helper'
+
+class StorageNodeTest < MiniTest::Unit::TestCase
+
+	def setup
+		create_tree
+		@resources = [1, 2, 3]
+		@root = @tree_definition.find(:job1).spawn @resources
+		@leaf = @tree_definition.find(:job2).spawn @resources, @root
+	end
+
+	def test_serialize
+		assert_equal '["tree1","job2",1,2,3]', @leaf.send(:serialize)
+	end
+
+	def test_storing
+		@leaf.store
+		assert_parent_key(
+      'ResqueJobsTree:Node:["tree1","job2",1,2,3]' => 'ResqueJobsTree:Node:["tree1","job1",1,2,3]')
+		assert_equal ['ResqueJobsTree:Node:["tree1","job2",1,2,3]'], redis.smembers(@root.childs_key)
+		@leaf.unstore
+		assert_parent_key({})
+		assert_equal [], redis.smembers(@root.childs_key)
+	end
+
+	def test_cleanup_for_root
+		create_3_nodes
+		@spawn1.cleanup
+		assert_equal [], redis.keys
+	end
+
+	def test_cleanup_for_leaf
+		create_3_nodes
+		@spawn3.cleanup
+		assert_equal [ 'ResqueJobsTree:Tree:Launched',
+                   'ResqueJobsTree:Node:Parents',
+                   'ResqueJobsTree:Node:["tree1","job1",1]:childs',
+                   'ResqueJobsTree:Node:["tree1","job2"]:childs'], redis.keys
+		assert_parent_key( 'ResqueJobsTree:Node:["tree1","job2"]' => 'ResqueJobsTree:Node:["tree1","job1",1]',
+                       'ResqueJobsTree:Node:["tree1","job3",2]' => 'ResqueJobsTree:Node:["tree1","job2"]')
+		assert_trees_key ['ResqueJobsTree:Tree:["tree1",1]']
+	end
+
+	def test_cleanup_for_not_root_nor_leaf
+		create_3_nodes
+		@spawn2.cleanup
+		assert_equal [ 'ResqueJobsTree:Tree:Launched',
+                   'ResqueJobsTree:Node:["tree1","job1",1]:childs'], redis.keys
+		assert_parent_key({})
+		assert_trees_key ['ResqueJobsTree:Tree:["tree1",1]']
+	end
+
+	def test_parent
+		@leaf.store
+		@leaf.instance_variable_set :@parent, nil
+		assert_equal @root.name, @leaf.parent.name
+		assert_equal @root.resources, @leaf.parent.resources
+	end
+
+	def test_only_stored_child
+		assert @leaf.only_stored_child?
+		@leaf.store
+		assert @leaf.only_stored_child?
+		resources2 = [4,5,6]
+		leaf2 = @tree_definition.find(:job2).spawn resources2, @root
+    leaf2.store
+		assert !@leaf.only_stored_child?
+	end
+
+	def test_stored_childs
+		@leaf.store
+		resources2 = [4,5,6]
+		leaf2 = @tree_definition.find(:job2).spawn resources2, @root
+    leaf2.store
+		assert_equal %w(job2 job2), @root.stored_childs.map(&:name)
+		assert_equal [[4,5,6],[1,2,3]], @root.stored_childs.map(&:resources)
+	end
+
+	def test_node_info_from_key
+		key = %Q{ResqueJobsTree:Node:["tree1","job1",1,2,3]}
+		result = ['job1', [1, 2, 3]]
+		assert_equal result, @root.send(:node_info_from_key, key)
+	end
+
+	private
+
+	def assert_parent_key expected
+		assert_equal expected, redis.hgetall(ResqueJobsTree::Storage::PARENTS_KEY)
+	end
+
+	def assert_trees_key expected
+		assert_equal expected, redis.smembers(ResqueJobsTree::Storage::LAUNCHED_TREES)
+	end
+
+	def create_3_nodes
+		@tree_definition = ResqueJobsTree::Factory.create :tree1 do
+			root :job1 do
+				perform {}
+				childs { [[:job2]] }
+				node :job2 do
+					perform {}
+					childs { [[:job3, 1],[:job3, 2]] }
+					node :job3 do
+						perform {|n|}
+					end
+				end
+			end
+		end
+		@tree = @tree_definition.spawn [1]
+		@spawn1 = @tree_definition.root.spawn [1]
+		@spawn2 = @tree_definition.find(:job2).spawn [], @spawn1
+		@spawn3 = @tree_definition.find(:job3).spawn [1], @spawn2
+		@spawn4 = @tree_definition.find(:job3).spawn [2], @spawn2
+		[@tree, @spawn2, @spawn3, @spawn4].each &:store
+	end
+
+end

data/test/storage_tree_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class StorageTreeTest < MiniTest::Unit::TestCase
+
+	def setup
+		create_tree
+		@resources = [Model.new(42), 2, 3]
+		@tree = @tree_definition.spawn @resources
+	end
+
+	def test_serialize
+		assert_equal '["tree1",["Model",42],2,3]', @tree.send(:serialize)
+	end
+
+	def test_key
+		assert_equal 'ResqueJobsTree:Tree:["tree1",["Model",42],2,3]', @tree.key
+	end
+
+	def test_storing
+		@tree.store
+		assert_equal ["ResqueJobsTree:Tree:[\"tree1\",[\"Model\",42],2,3]"],
+			redis.smembers(ResqueJobsTree::Storage::LAUNCHED_TREES)
+		@tree.unstore
+		assert_equal [], redis.smembers(ResqueJobsTree::Storage::LAUNCHED_TREES)
+	end
+
+end

data/test/test_helper.rb

@@ -12,8 +12,6 @@ $TESTING = true
 require 'mock_redis'
 Resque.redis = MockRedis.new
 
-Resque.inline = true
-
 #
 # Fixtures
 #
@@ -36,12 +34,22 @@ class ExpectedException < Exception ; end
 
 class MiniTest::Unit::TestCase
 
+  def setup
+    Resque.inline = true
+  end
+
+  private
+
   def teardown
     redis.keys.each{ |key| redis.del key }
   end
 
+  def redis
+    Resque.redis
+  end
+
   def create_tree
-    @tree = ResqueJobsTree::Factory.create :tree1 do
+    @tree_definition = ResqueJobsTree::Factory.create :tree1 do
       root :job1 do
         perform do |*args|
           Resque.redis.rpush 'history', 'tree1 job1'
@@ -62,12 +70,8 @@ class MiniTest::Unit::TestCase
     end
   end
 
-  def redis
-    Resque.redis
-  end
-
   def create_nested_tree
-    @tree = ResqueJobsTree::Factory.create :tree1 do
+    @tree_definition = ResqueJobsTree::Factory.create :tree1 do
       root :job1 do
         perform { raise ExpectedException, 'job1' }
         childs { [ [:job2] ] }

data/test/tree_test.rb

@@ -7,130 +7,35 @@ class TreeTest < MiniTest::Unit::TestCase
   end
 
   def test_name
-    assert_equal @tree.name, 'tree1'
+    assert_equal @tree_definition.name, 'tree1'
   end
 
-  def test_jobs
-    assert_equal @tree.jobs, []
+  def test_leaves
+    assert_equal @tree_definition.spawn([]).leaves, []
   end
 
   def test_root
-    assert @tree.root.kind_of? ResqueJobsTree::Node
+    assert @tree_definition.root.kind_of? ResqueJobsTree::Definitions::Node
   end
 
-  def test_enqueue
-    job_args = [:job4, ['Model', 1], 123]
-    @tree.enqueue *job_args
-    assert_equal @tree.jobs.first, ['tree1', :job4, ['Model', 1], 123]
+  def test_register_a_leaf
+    leaf = 'leaf'
+    tree = @tree_definition.spawn []
+    tree.register_a_leaf leaf
+    assert_equal tree.leaves, [leaf]
   end
 
-  def test_find_node_by_name
-    assert_equal 'job2', @tree.find_node_by_name('job2').name
-    create_nested_tree
-    assert_equal 'job4', @tree.find_node_by_name('job4').name
-  end
-
-  def test_launch
-    resources = [1, 2, 3]
-    @tree.launch *resources
-    history = ['tree1 job2']*3+['tree1 job1']
-    assert_equal history, redis.lrange('history', 0, -1)
-  end
-
-  def test_launch_with_no_resources
-    @tree.launch
+  def test_find
+    assert_equal 'job2', @tree_definition.find(:job2).name
+    tree_definition = create_nested_tree
+    assert_equal 'job4', tree_definition.find(:job4).name
   end
 
   def test_should_have_root
-    assert_raises ResqueJobsTree::TreeInvalid do
+    assert_raises ResqueJobsTree::TreeDefinitionInvalid do
       ResqueJobsTree::Factory.create :tree1 do
       end
     end
   end
 
-  def test_on_failure
-    create_tree_with_on_failure_hook
-    assert_raises ExpectedException do
-      @tree.launch
-    end
-  end
-
-  def test_tree_with_resource
-    create_tree_with_resources
-    @tree.launch Model.new(1)
-  end
-
-  def test_nested_tree
-    create_nested_tree
-    assert_raises RuntimeError do # job4 error !
-      @tree.launch
-    end
-    assert_raises NoMethodError do # job3 error !
-      Resque.enqueue_to 'tree1', ResqueJobsTree::Job, 'tree1', 'job3'
-    end
-  end
-
-  def test_async_tree
-    tree = ResqueJobsTree::Factory.create :tree1 do
-      root :job1 do
-        perform { raise 'should not arrive here' }
-        childs { [ [:job2], [:job3] ] }
-        node :job2, async: true do
-          perform {}
-        end
-        node :job3 do
-          perform {}
-        end
-      end
-    end
-    tree.launch
-    assert_equal ["ResqueJobsTree:Node:[\"tree1\",\"job2\"]"],
-      Resque.redis.smembers("ResqueJobsTree:Node:[\"tree1\",\"job1\"]:childs")
-    parents_hash = { 'ResqueJobsTree:Node:["tree1","job2"]'=>'ResqueJobsTree:Node:["tree1","job1"]' }
-    assert_equal parents_hash, Resque.redis.hgetall(ResqueJobsTree::Storage::PARENTS_KEY)
-  end
-
-  def test_async_tree_with_fail
-    tree = ResqueJobsTree::Factory.create :tree1 do
-      root :job1 do
-        perform { raise 'should not arrive here' }
-        childs { [ [:job2], [:job3] ] }
-        node :job2, async: true do
-          perform {}
-        end
-        node :job3, continue_on_failure: true do
-          perform { raise ExpectedException, 'an expected failure' }
-        end
-      end
-    end
-    assert_raises ExpectedException do
-      tree.launch
-    end
-    assert_equal ["ResqueJobsTree:Node:[\"tree1\",\"job2\"]"],
-      Resque.redis.smembers("ResqueJobsTree:Node:[\"tree1\",\"job1\"]:childs")
-  end
-
-  private
-
-  def create_tree_with_on_failure_hook
-    @tree = ResqueJobsTree::Factory.create :tree1 do
-      root :job1 do
-        perform { raise ExpectedException, 'job1' }
-      end
-      on_failure do
-        raise ExpectedException, 'called from on_failure block'
-      end
-    end
-  end
-
-  def create_tree_with_resources
-    @tree = ResqueJobsTree::Factory.create :tree1 do
-      root :job1 do
-        perform do |resources|
-          raise 'unknown resource' unless resources.first.kind_of?(Model)
-        end
-      end
-    end
-  end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque_jobs_tree
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-11 00:00:00.000000000 Z
+date: 2013-04-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -105,19 +105,26 @@ files:
 - README.md
 - Rakefile
 - lib/resque_jobs_tree.rb
+- lib/resque_jobs_tree/definitions.rb
+- lib/resque_jobs_tree/definitions/node.rb
+- lib/resque_jobs_tree/definitions/tree.rb
 - lib/resque_jobs_tree/factory.rb
 - lib/resque_jobs_tree/job.rb
 - lib/resque_jobs_tree/node.rb
 - lib/resque_jobs_tree/resources_serializer.rb
 - lib/resque_jobs_tree/storage.rb
+- lib/resque_jobs_tree/storage/node.rb
+- lib/resque_jobs_tree/storage/tree.rb
 - lib/resque_jobs_tree/tree.rb
 - lib/resque_jobs_tree/version.rb
 - resque_jobs_tree.gemspec
+- test/definitions_test.rb
 - test/factory_test.rb
 - test/job_test.rb
-- test/node_test.rb
+- test/process_test.rb
 - test/resources_serializer_test.rb
-- test/storage_test.rb
+- test/storage_node_test.rb
+- test/storage_tree_test.rb
 - test/test_helper.rb
 - test/tree_test.rb
 homepage: ''
@@ -146,11 +153,13 @@ signing_key:
 specification_version: 3
 summary: Organise Resque jobs as a tree.
 test_files:
+- test/definitions_test.rb
 - test/factory_test.rb
 - test/job_test.rb
-- test/node_test.rb
+- test/process_test.rb
 - test/resources_serializer_test.rb
-- test/storage_test.rb
+- test/storage_node_test.rb
+- test/storage_tree_test.rb
 - test/test_helper.rb
 - test/tree_test.rb
 has_rdoc: 

data/test/node_test.rb

@@ -1,188 +0,0 @@
-require 'test_helper'
-
-class NodeTest < MiniTest::Unit::TestCase
-
-  def setup
-    @tree = ResqueJobsTree::Tree.new :tree1
-    @root = ResqueJobsTree::Node.new :node1, @tree
-    @leaf = ResqueJobsTree::Node.new :node2, @tree, @root
-  end
-
-  def test_ressources
-    variable = 1
-    @root.resources do |n|
-      variable = n
-    end
-    @root.resources.call 2
-    assert_equal variable, 2
-  end
-
-  def test_perform
-    variable = 1
-    @root.perform do |n|
-      variable = n
-    end
-    @root.perform.call 2
-    assert_equal variable, 2
-  end
-
-  def test_childs
-    variable = 1
-    @leaf.childs do |n|
-      variable = n
-    end
-    @leaf.childs.call 2
-    assert_equal variable, 2
-  end
-
-  def test_node
-    node3 = @root.node :node3
-    assert_equal @root.find_node_by_name('node3').object_id, node3.object_id
-  end
-
-  def test_leaf
-    resources = []
-    assert @leaf.leaf?(resources)
-    @root.childs do |resources|
-      [:node2, resources]
-    end
-    assert !@root.leaf?(resources)
-  end
-
-  def test_root
-    assert @root.root?
-    assert !@leaf.root?
-  end
-
-  def test_siblings
-    node3 = ResqueJobsTree::Node.new :node3, @tree, @root
-    assert @leaf.siblings, [node3]
-  end
-
-  def test_launch
-    resources = [1, 2, 3]
-    @leaf.launch resources, resources
-    assert_equal @tree.jobs.first, ['tree1', 'node2', 1, 2, 3]
-  end
-
-  def test_childs_validation
-    assert_raises ResqueJobsTree::NodeInvalid do
-      ResqueJobsTree::Factory.create :tree1 do
-        root :job1 do
-          perform {}
-          childs {}
-        end
-      end
-    end
-    ResqueJobsTree::Factory.create :tree1 do
-      root :job1 do
-        perform {}
-      end
-    end
-  end
-
-  def test_perform_validation
-    assert_raises ResqueJobsTree::NodeInvalid do
-      ResqueJobsTree::Factory.create :tree1 do
-        root :job1 do
-        end
-      end
-    end
-  end
-
-  def test_perform_validation
-    assert_raises ResqueJobsTree::NodeInvalid do
-      ResqueJobsTree::Factory.create :tree1 do
-        root :job1 do
-          perform {}
-          childs {}
-          node :job2 do
-            perform {}
-          end
-          node :job2 do
-            perform {}
-          end
-        end
-      end
-    end
-  end
-
-  def test_options
-    create_async_tree
-    options = { async: true }
-    assert_equal options, @tree.find_node_by_name(:job2).options
-  end
-
-  def test_launch_async
-    create_async_tree
-    resources = [1, 2, 3]
-    @tree.launch resources
-    assert @tree.jobs.empty?
-  end
-
-  def test_launch_continue_on_failure
-    tree = ResqueJobsTree::Factory.create :tree1 do
-      root :job1 do
-        perform { raise ExpectedException, 'an expected failure' }
-        childs { [:job2] }
-        node :job2, continue_on_failure: true do
-          perform { raise 'an expected failure' }
-        end
-      end
-    end
-    resources = [1, 2, 3]
-    assert_raises ExpectedException do
-      tree.launch resources
-    end
-    assert_equal [], Resque.keys
-  end
-
-  def test_leaf_failure
-    tree = ResqueJobsTree::Factory.create :tree1 do
-      root :job1 do
-        perform {}
-        childs { [:job2] }
-        node :job2 do
-          perform { raise ExpectedException, 'an expected exception'}
-        end
-      end
-    end
-    resources = [1, 2, 3]
-    assert_raises ExpectedException do
-      tree.launch *resources
-    end
-    assert_equal [], Resque.keys
-  end
-
-  def test_root_failure
-    tree = ResqueJobsTree::Factory.create :tree1 do
-      root :job1 do
-        perform { raise ExpectedException, 'an expected exception' }
-        childs { [:job2] }
-        node :job2 do
-          perform {}
-        end
-      end
-    end
-    resources = [1, 2, 3]
-    assert_raises ExpectedException do
-      tree.launch resources
-    end
-    assert_equal [], Resque.keys
-  end
-
-  private
-
-  def create_async_tree
-    @tree = ResqueJobsTree::Factory.create :tree1 do
-      root :job1 do
-        perform { raise 'should not arrive here' }
-        childs { [:job2] }
-        node :job2, async: true do
-          perform {}
-        end
-      end
-    end
-  end
-
-end