patriarch 0.0.4 → 0.1.0

data/spec/lib/patriarch/behaviours_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+
+describe Patriarch::Behaviours do
+  describe '#add_behaviour' do
+
+    let(:monster)      { Monster.new }
+    let(:fallen_angel) { FallenAngel.new }
+    let(:love_letter)  { LoveLetter.new }
+
+
+
+    context 'on a bipartite' do
+
+      before do 
+        # Monster is the actor model and FallenAngel the target model here
+        Monster.add_behaviour       :like, :on => [:fallenAngel] 
+        FallenAngel.add_behaviour   :like, :by => [:monster]
+        monster.like fallen_angel
+      end
+
+      context "call from a model including Patriarch::Behaviours" do
+
+        it "defines instances methods to retrieve model instances having relationships with actor model" do
+          monster.should          respond_to("#{"fallen_angel".pluralize}_i_like")
+        end
+
+        it "defines instances methods to retrieve ids of model instances having relationships with actor model" do
+          monster.should          respond_to("#{"fallen_angel".pluralize}_i_like_ids")
+        end      
+
+        it "defines instances methods to retrieve model instances having relationships with target model" do
+          progressive_like = (Verbs::Conjugator.conjugate :like, :aspect => :progressive).split(/ /).last
+          fallen_angel.should     respond_to("#{"monster".pluralize}_#{progressive_like}_me")
+        end
+
+        it "defines instances methods to retrieve ids of model instances having relationships with target model" do
+          progressive_like = (Verbs::Conjugator.conjugate :like, :aspect => :progressive).split(/ /).last
+          fallen_angel.should     respond_to("#{"monster".pluralize}_#{progressive_like}_me_ids")
+        end
+
+        it "defines behaviour instance method on actor model" do
+          monster.should          respond_to(:like)
+        end
+        
+        it "defines undo behaviour instance method on actor model" do
+          monster.should          respond_to(:undo_like)
+        end
+
+        it "defines alias for behaviour instance methods on actor model" do
+          pending("implement this with add_behaviour ARGUMENTS, [:as => alias]")
+        end
+
+        it "defines alias for undo behaviour instance methods on actor model" do
+          pending("implement this with add_behaviour ARGUMENTS, [:undo_as => alias]")
+        end      
+
+        it "does not define behaviour instance method on target model" do
+          fallen_angel.should_not respond_to(:like)
+        end
+
+        it "does not define undo behaviour instance method on target model" do
+          fallen_angel.should_not respond_to(:undo_like)
+        end
+
+        it "does not define alias for behaviour instance methods on target model" do
+          pending("implement this with add_behaviour ARGUMENTS, [:as => alias]")
+        end
+
+        it "does not define alias for undo behaviour instance methods on target model" do
+          pending("implement this with add_behaviour ARGUMENTS, [:undo_as => alias]")
+        end      
+      end
+
+      context 'implements methods that' do
+
+        # Move tests in da right place ? Does it belongs to manager_service ?
+        it 'lets transaction build without running' do
+          monster.like(fallen_angel, :stop_execution => true).should be_an_instance_of(Patriarch::Transaction)
+        end
+
+        it 'lets undo transaction build without running' do
+          monster.undo_like(fallen_angel, :stop_execution => true).should be_an_instance_of(Patriarch::Transaction)
+        end      
+
+        before(:all) { monster.like fallen_angel }
+
+        context 'when doing behaviour' do
+          it "allows actor to remember target id" do 
+            monster.fallen_angels_i_like_ids.should == [fallen_angel.id]
+          end
+
+          it "allows actor to remember target instance" do 
+            monster.fallen_angels_i_like.should == [fallen_angel]
+          end
+          
+          it "allows target to remember actor id" do 
+            fallen_angel.monsters_liking_me_ids.should == [monster.id]        
+          end
+
+          it "allows target to remember actor instance" do 
+            fallen_angel.monsters_liking_me.should == [monster]
+          end      
+        end
+
+        context 'when undoing behaviour' do
+          it "erase target id from actor's memory" do 
+            monster.fallen_angels_i_like_ids.should == [fallen_angel.id]
+          end
+
+          it "erase target instance from actor's memory" do 
+            monster.fallen_angels_i_like.should == [fallen_angel]
+          end
+          
+          it "erase actor id from target's memory" do 
+            fallen_angel.monsters_liking_me_ids.should == [monster.id]        
+          end
+
+          it "erase actor instance from target's memory" do 
+            fallen_angel.monsters_liking_me.should == [monster]
+          end     
+        end
+
+        after(:all) { monster.undo_like fallen_angel }
+      end 
+    end # context bipartite
+
+    context 'on a tripartite' do
+
+      before do 
+        # Monster is the actor model and FallenAngel the target model here
+        Monster.add_behaviour       :praise, :on => [:fallenAngel], :via => [:loveLetter]
+        FallenAngel.add_behaviour   :praise, :by => [:monster], :via => [:loveLetter]
+        LoveLetter.add_behaviour    :praise, :medium_between => [:monster,:fallenAngel]
+        monster.praise(fallen_angel,love_letter)
+      end
+
+      context "call from a model including Patriarch::Behaviours" do
+        it "defines instances methods to retrieve model instances having relationships with actor model" do
+          monster.should          respond_to("#{"fallen_angel".pluralize}_i_praise_via_#{"love_letter".pluralize}")
+        end
+
+        it "defines instances methods to retrieve ids of model instances having relationships with actor model" do
+          monster.should          respond_to("#{"fallen_angel".pluralize}_i_praise_via_#{"love_letter".pluralize}_ids")
+        end      
+
+        it "defines instances methods to retrieve model instances having relationships with target model" do
+          progressive_praise = (Verbs::Conjugator.conjugate :praise, :aspect => :progressive).split(/ /).last
+          fallen_angel.should     respond_to("#{"monster".pluralize}_#{progressive_praise}_me_via_#{"love_letter".pluralize}")
+        end
+
+        it "defines instances methods to retrieve ids of model instances having relationships with target model" do
+          progressive_praise = (Verbs::Conjugator.conjugate :praise, :aspect => :progressive).split(/ /).last
+          fallen_angel.should     respond_to("#{"monster".pluralize}_#{progressive_praise}_me_via_#{"love_letter".pluralize}_ids")
+        end
+
+        it "defines behaviour instance method on actor model" do
+          monster.should          respond_to(:praise)
+        end
+        
+        it "defines undo behaviour instance method on actor model" do
+          monster.should          respond_to(:undo_praise)
+        end
+
+        it "does not define behaviour instance method on target model" do
+          fallen_angel.should_not respond_to(:praise)
+        end
+
+        it "does not define undo behaviour instance method on target model" do
+          fallen_angel.should_not respond_to(:undo_praise)
+        end
+
+        it "does not define behaviour instance method on medium model" do
+          love_letter.should_not respond_to(:praise)
+        end
+
+        it "does not define undo behaviour instance method on medium model" do
+          love_letter.should_not respond_to(:undo_praise)
+        end        
+      end
+      
+      context 'implements methods that' do 
+        it 'lets transaction build without running' do
+          monster.praise(fallen_angel, love_letter, :stop_execution => true).should be_an_instance_of(Patriarch::Transaction)
+        end
+
+        it 'lets undo transaction build without running' do
+          monster.praise(fallen_angel, love_letter, :stop_execution => true).should be_an_instance_of(Patriarch::Transaction)
+        end
+
+        before(:all) { monster.praise fallen_angel,love_letter }
+
+        context 'when doing behaviour' do
+          it "allows actor to remember target id" do 
+            monster.fallen_angels_i_praise_via_love_letters_ids.should == [fallen_angel.id]
+          end
+
+          it "allows actor to remember target instance" do 
+            monster.fallen_angels_i_praise_via_love_letters.should == [fallen_angel]
+          end
+          
+          it "allows target to remember actor id" do 
+            fallen_angel.monsters_praising_me_via_love_letters_ids.should == [monster.id]        
+          end
+
+          it "allows target to remember actor instance" do 
+            fallen_angel.monsters_praising_me_via_love_letters.should == [monster]
+          end      
+        end
+
+        context 'when undoing behaviour' do
+          it "erase target id from actor's memory" do 
+            monster.fallen_angels_i_praise_via_love_letters_ids.should == [fallen_angel.id]
+          end
+
+          it "erase target instance from actor's memory" do 
+            monster.fallen_angels_i_praise_via_love_letters.should == [fallen_angel]
+          end
+          
+          it "erase actor id from target's memory" do 
+            fallen_angel.monsters_praising_me_via_love_letters_ids.should == [monster.id]        
+          end
+
+          it "erase actor instance from target's memory" do 
+            fallen_angel.monsters_praising_me_via_love_letters.should == [monster]
+          end     
+        end
+
+        after(:all) { monster.undo_praise fallen_angel,love_letter }
+      end
+    end # context tripartite
+
+  end # desc '#add_behaviour'
+end # desc Patriarch::Behaviours

data/spec/lib/patriarch/{bipartite_relationship_builder_spec.rb → dao_services/bipartite_relationship_builder_spec.rb}

@@ -1,24 +1,27 @@
 require 'spec_helper'
 
 describe Patriarch::DAOServices::BipartiteRelationshipBuilderService do
+  
+  let(:monster)       { Monster.new }
+  let(:fallen_angel)  { FallenAngel.new }
+  let(:instance)      { Patriarch::DAOServices::BipartiteRelationshipBuilderService.instance }
+
   before(:each) do
-    @instance = Patriarch::DAOServices::BipartiteRelationshipBuilderService.instance
-    @monster        = new_monster
-    @fallen_angel   = new_fallen_angel
+    # Deals with transaction
     @transac ||= Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction(:like)
-    @transac.add_step(:like,@monster,@fallen_angel)
-  end
-
-  it "shall insert processable lambdas into queues when create is called" do
+    @transac.add_step(:like,monster,fallen_angel)
+    
     # Stubs the DAO retriever service so it gives DAO arrays back
     dao_sample = { 
-      :actor => Redis::SortedSet.new("monster:1:patriarch_fallen_angels_i_like"), 
-      :target => Redis::SortedSet.new("fallen_angel:1:patriarch_monsters_liking_me")
+      :actor => Redis::SortedSet.new("monster:#{monster.id}:patriarch_fallen_angels_i_like"), 
+      :target => Redis::SortedSet.new("fallen_angel:#{fallen_angel.id}:patriarch_monsters_liking_me")
     }
-    Patriarch::DAOServices::RetrieverService.instance.stub(:call).twice.with(any_args()).and_return(dao_sample)
-    
+    Patriarch::DAOServices::RetrieverService.instance.stub(:call).twice.with(any_args()).and_return(dao_sample) 
+  end
+
+  it "shall insert processable lambdas into queues when create is called" do
     expect{
-      @instance.create(@transac)
+      instance.create(@transac)
     }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? Proc}.size }.by(2)
   
     expect{
@@ -27,15 +30,8 @@ describe Patriarch::DAOServices::BipartiteRelationshipBuilderService do
   end
 
   it "shall insert processable lambdas into queues when destroy is called" do
-    # Stubs the DAO retriever service so it gives DAO arrays back
-    dao_sample = { 
-      :actor => Redis::SortedSet.new("monster:1:patriarch_fallen_angels_i_like"), 
-      :target => Redis::SortedSet.new("fallen_angel:1:patriarch_monsters_liking_me")
-    }
-    Patriarch::DAOServices::RetrieverService.instance.stub(:call).twice.with(any_args()).and_return(dao_sample)
-    
     expect{
-      @instance.destroy(@transac)
+      instance.destroy(@transac)
     }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? Proc}.size }.by(2)
 
     expect{
@@ -44,7 +40,7 @@ describe Patriarch::DAOServices::BipartiteRelationshipBuilderService do
   end
 
   after(:each) do
-    $redis.del "monster:#{@monster.id}:patriarch_fallen_angels_i_like"
-    $redis.del "fallen_angel:#{@fallen_angel.id}:patriarch_monsters_liking_me"
+    $redis.del "monster:#{monster.id}:patriarch_fallen_angels_i_like"
+    $redis.del "fallen_angel:#{fallen_angel.id}:patriarch_monsters_liking_me"
   end
-end
+end

data/spec/lib/patriarch/dao_services/tripartite_relationship_builder_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Patriarch::DAOServices::TripartiteRelationshipBuilderService do
+  
+  let(:monster)       { Monster.new }
+  let(:fallen_angel)  { FallenAngel.new }
+  let(:love_letter)   { LoveLetter.new }
+  let(:instance)      { Patriarch::DAOServices::TripartiteRelationshipBuilderService.instance }
+
+  before(:each) do
+    # Deals with transaction
+    @transac ||= Patriarch::TransactionServices::TransactionManagerService.instance.new_transaction(:praise)
+    @transac.add_step(:praise,monster,fallen_angel,love_letter)
+    
+    # Stubs the DAO retriever service so it gives DAO arrays back
+    dao_sample = { 
+      :actor => Redis::SortedSet.new("monster:#{monster.id}:patriarch_fallen_angels_i_praise_via_love_letters",:marshal => true), 
+      :target => Redis::SortedSet.new("fallen_angel:#{fallen_angel.id}:patriarch_monsters_prasing_me_via_love_letters",:marshal => true),
+      :medium => Redis::SortedSet.new("love_letter:#{fallen_angel.id}:patriarch_monsters_prasing_fallen_angels_via_me",:marshal => true)
+    }
+    Patriarch::DAOServices::RetrieverService.instance.stub(:call).exactly(3).times.with(any_args()).and_return(dao_sample) 
+  end
+
+  it "shall insert processable lambdas into queues when create is called" do
+    expect{
+      instance.create(@transac)
+    }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? Proc}.size }.by(3)
+  
+    expect{
+      @transac.transaction_queue.each{ |proc| proc.call }
+    }.to change{ $redis.keys.size}.by(3)
+  end
+
+  it "shall insert processable lambdas into queues when destroy is called" do
+    expect{
+      instance.destroy(@transac)
+    }.to change{ @transac.transaction_queue.select{ |queue_element| queue_element.is_a? Proc}.size }.by(3)
+
+    expect{
+      @transac.transaction_queue.each{ |proc| proc.call }
+    }.to change{ $redis.info["total_commands_processed"].to_i}.by(4)
+  end
+
+  after(:each) do
+    $redis.del "monster:#{monster.id}:patriarch_fallen_angels_i_praise_via_love_letters"
+    $redis.del "fallen_angel:#{fallen_angel.id}:patriarch_monsters_prasing_me_via_love_letters"
+    $redis.del "love_letter:#{fallen_angel.id}:patriarch_monsters_prasing_fallen_angels_via_me"
+  end
+end

data/spec/lib/patriarch/redis_mapper_service_spec.rb

@@ -1,21 +1,53 @@
 require 'spec_helper'
 
 describe Patriarch::DAOServices::RedisMapperService do
-  before(:each) do
-    @instance = Patriarch::DAOServices::RedisMapperService.instance
-    @context = {:relation_type => :like, :actor_type => :monster, :target_type => :fallen_angel, 
-    :actor_id => 1, :target_id => 1}
-    @transaction_item = double()
-    @transaction_item.stub(:relation_type).and_return(@context[:relation_type])
-    @transaction_item.stub(:actor_type).and_return(@context[:actor_type])
-    @transaction_item.stub(:target_type).and_return(@context[:target_type])    
-  end
 
-  it "shall retrieve right DAO information" do
-    @instance.call(@transaction_item,:actor).should eq({:type => "sorted_set", :key => "patriarch_fallen_angels_i_like"})
-    @instance.call(@transaction_item,:target).should eq({:type => "sorted_set", :key => "patriarch_monsters_liking_me"})
-  end
-end
+  context "in bipartite situations" do
+
+    before do
+      @instance = Patriarch::DAOServices::RedisMapperService.instance
+      @context = {:relation_type => :like, :actor_type => :monster, :target_type => :fallen_angel, 
+      :actor_id => 1, :target_id => 1}
+      @transaction_item = double()
+      @transaction_item.stub(:relation_type).and_return(@context[:relation_type])
+      @transaction_item.stub(:actor_type).and_return(@context[:actor_type])
+      @transaction_item.stub(:target_type).and_return(@context[:target_type])   
+      @transaction_item.stub(:medium_type).and_return(@context[:medium_type]) 
+      @transaction_item.stub(:tripartite?).and_return(false)      
+    end 
+
+    it "retrieves DAO" do
+      @instance.call(@transaction_item,:actor).should eq({:type => "sorted_set", :key => "patriarch_fallen_angels_i_like"})
+      @instance.call(@transaction_item,:target).should eq({:type => "sorted_set", :key => "patriarch_monsters_liking_me"})
+    end
+  end # bipartite context
+
+  context "in tripartite situations" do
+    before do
+      @instance = Patriarch::DAOServices::RedisMapperService.instance
+      @context = {:relation_type => :tease, :actor_type => :fallen_angel, :target_type => :monster, :medium_type => :love_letter,
+      :actor_id => 1, :target_id => 1, :medium_id => 1}
+      @transaction_item = double()
+      @transaction_item.stub(:relation_type).and_return(@context[:relation_type])
+      @transaction_item.stub(:actor_type).and_return(@context[:actor_type])
+      @transaction_item.stub(:target_type).and_return(@context[:target_type])    
+      @transaction_item.stub(:medium_type).and_return(@context[:medium_type]) 
+      @transaction_item.stub(:tripartite?).and_return(true)
+    end 
+    
+    it "retrieves DAO" do
+      @instance.call(@transaction_item,:actor).should eq(
+        {:type => "sorted_set", :key => "patriarch_monsters_i_tease_via_love_letters", :options => {:marshal => true}}
+      )
+      @instance.call(@transaction_item,:target).should eq(
+        {:type => "sorted_set", :key => "patriarch_fallen_angels_teasing_me_via_love_letters",:options => {:marshal => true}}
+      )
+      @instance.call(@transaction_item,:medium).should eq(
+        {:type => "sorted_set", :key => "patriarch_fallen_angels_teasing_monsters_via_me",:options => {:marshal => true}}
+      )
+    end
+  end #tripartite context
+end # describe
 
 
     

data/spec/lib/patriarch/retriever_service_spec.rb

@@ -1,28 +1,47 @@
 require 'spec_helper'
 
 describe Patriarch::DAOServices::RetrieverService do
+
   before(:each) do
     @instance = Patriarch::DAOServices::RetrieverService.instance
-    @context = {:relation_type => :like, :actor_type => :user, :target_type => :item, 
+    @context = {:relation_type => :like, :actor_type => :monster, :target_type => :fallen_angel, 
     :actor_id => 1, :target_id => 1}
     @transaction_item = double()
     @transaction_item.stub(:actor_id).and_return(@context[:actor_id])
     @transaction_item.stub(:actor_type).and_return(@context[:actor_type])
     @transaction_item.stub(:target_type).and_return(@context[:target_type])
-    @transaction_item.stub(:target_id).and_return(@context[:target_id])        
+    @transaction_item.stub(:target_id).and_return(@context[:target_id])          
   end
 
-  it "shall return nice Redis::Object instances" do
+  it "returns DAO for actor" do
+    @transaction_item.stub(:tripartite?).and_return(false)          
     Patriarch::DAOServices::RedisMapperService.instance.should_receive(:call).twice.with(any_args()).and_return({:type => "sorted_set", :key =>"abc"})
     dao_tab = @instance.call(@transaction_item)
 
-    dao_tab[:actor].key.should == "user:1:abc"
-    dao_tab[:actor].is_a?(Redis::SortedSet).should be_true
-
-    dao_tab[:target].key.should == "item:1:abc"
-    dao_tab[:target].is_a?(Redis::SortedSet).should be_true
+    dao_tab[:actor].key.should == "monster:1:abc"
+    dao_tab[:actor].is_a?(Redis::SortedSet).should be_true       
   end
 
+  it "returns DAO for target" do
+    @transaction_item.stub(:tripartite?).and_return(false)       
+    Patriarch::DAOServices::RedisMapperService.instance.should_receive(:call).twice.with(any_args()).and_return({:type => "sorted_set", :key =>"abc"})
+    dao_tab = @instance.call(@transaction_item)
+
+    dao_tab[:target].key.should == "fallen_angel:1:abc"
+    dao_tab[:target].is_a?(Redis::SortedSet).should be_true    
+  end    
+
+  it "returns DAO for medium" do
+    @context.merge! :medium_type => :love_letter, :medium_id => 1
+    @transaction_item.stub(:medium_type).and_return(@context[:medium_type])
+    @transaction_item.stub(:medium_id).and_return(@context[:medium_id])   
+    @transaction_item.stub(:tripartite?).and_return(true)   
+    Patriarch::DAOServices::RedisMapperService.instance.should_receive(:call).exactly(3).times.with(any_args()).and_return({:type => "sorted_set", :key =>"abc"})
+    dao_tab = @instance.call(@transaction_item)
+
+    dao_tab[:medium].key.should == "love_letter:1:abc"
+    dao_tab[:medium].is_a?(Redis::SortedSet).should be_true
+  end      
 
   it "shall reject types that are not suited" do
     Patriarch::DAOServices::RedisMapperService.instance.should_receive(:call).with(any_args()).and_return({:type => "sorted", :key =>"abc"})

data/spec/lib/patriarch/tool_services/redis_cleaner_service_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Patriarch::ToolServices::RedisCleanerService.instance do
+
+  let(:monster)      { Monster.new }
+  let(:beast)        { Monster.new }
+  # Wrong usage when summoning several times fallen_angel within tests; bad knowledge of 
+  # let is in cause i think
+  # let(:fallen_angel) { FallenAngel.new }
+  let(:instance)     { Patriarch::ToolServices::RedisCleanerService.instance }
+
+  context "#clean_all" do
+    it "removes presence into other sets for each behaviour" do
+      pending("implement this")
+    end
+
+    it "removes presence into other set for a given behaviour" do
+      pending("implement this")
+    end
+  end 
+
+  context "#clean_behaviour" do
+    it "removes given behaviour binds on self" do
+      f = FallenAngel.new
+      f.lure Monster.new
+      instance.clean_behaviour(f,:lure)
+      f.monsters_i_lure.should be_empty
+    end
+
+    it "removes given behaviour binds on other entities" do
+      f = FallenAngel.new
+      f.lure Monster.new      
+      instance.clean_behaviour(f,:lure)
+      beast.fallen_angels_luring_me.include?(f).should be_false
+      monster.fallen_angels_luring_me.include?(f).should be_false      
+    end
+
+    it "runs within a unique transaction" do
+      f = FallenAngel.new
+      10.times { |t| f.lure Monster.new }
+      before_count = Patriarch::TransactionServices::TransactionManagerService.instance.count
+        instance.clean_behaviour(f,:lure)
+      after_count = Patriarch::TransactionServices::TransactionManagerService.instance.count
+      (after_count - before_count).should eq(1)
+    end
+  end
+
+end # desc Patriarch::Behaviours::RedisCleanerService.instance

data/spec/lib/patriarch/transaction_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Patriarch::Transaction do
+  
+  let(:monster)         { Monster.new }
+  let(:fallen_angel)    { FallenAngel.new }
+  let(:love_letter)     { LoveLetter.new }
+  let(:transaction_step){ Patriarch::TransactionStep.new(:pick_up,monster,fallen_angel,love_letter)  }
+  let(:transaction)     { Patriarch::Transaction.new(:transaction_test,42) }
+
+  context "forwards to current step" do 
+  end
+end

data/spec/lib/patriarch/transaction_step_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Patriarch::TransactionStep do
+  
+  let(:monster)         { Monster.new }
+  let(:fallen_angel)    { FallenAngel.new }
+  let(:love_letter)     { LoveLetter.new }
+  let(:transaction_step){ Patriarch::TransactionStep.new(:pick_up,monster,fallen_angel,love_letter)  }
+
+  it "#actor returns the actor instance" do
+    transaction_step.actor.should == [monster] 
+  end
+
+  it "#medium returns the medium instance" do
+    transaction_step.medium.should == [love_letter] 
+  end
+
+  it "#target returns the target instance" do
+    transaction_step.target.should == [fallen_angel] 
+  end 
+
+  it "#add_to_queue appends proc to queue" do 
+    p = Proc.new { p "do_nothing"}
+    q = Proc.new { p "do_nothing"}
+    transaction_step.add_to_queue p
+    transaction_step.add_to_queue q
+    transaction_step.queue.should ==[p,q]
+  end
+end

data/spec/spec_helper.rb

@@ -12,7 +12,7 @@ require 'action_view'
 require 'rails/generators'
 require 'rspec/autorun'
 
-require File.expand_path("../../lib/generators/patriarch/patriarch_generator", __FILE__)
+#require File.expand_path("../../lib/generators/patriarch/behaviour_generator", __FILE__)
 
 RSpec.configure do |config|
   # ## Mock Framework
@@ -36,18 +36,22 @@ puts "Cleaning previous dummy"
 # Destroy previously initialized files in dummy, clean up !
 puts "Generating files to be tested in a dummy"
 
+puts "Installing gem .."
+Patriarch::Generators::InstallGenerator.start(%w(fake_arg),:destination_root => dummy_location) 
+
 # Initialize files in dummy :)
 # Capture prevents stdout outputs from code between curly braces to be displayed
 # This avoid polluting user interface 
-capture(:stdout) { PatriarchGenerator.start(%w(like),{:destination_root => dummy_location}) }
+Patriarch::Generators::BehaviourGenerator.start(%w(like),{:destination_root => dummy_location}) 
+Patriarch::Generators::BehaviourGenerator.start(%w(lure),{:destination_root => dummy_location}) 
+Patriarch::Generators::BehaviourGenerator.start(%w(praise tripartite),{:destination_root => dummy_location}) 
 
 #Enhance load_path with dummy located files ...
 $LOAD_PATH << File.expand_path("../../spec/dummy/lib", __FILE__)
 $LOAD_PATH << File.expand_path("../../lib", __FILE__)
 
-# load files living in the dummy ...
-require File.expand_path("../../spec/dummy/lib/patriarch/services/like", __FILE__)
-require File.expand_path("../../spec/dummy/lib/patriarch/behaviours/like", __FILE__)
+# load files living in the dummy using initilizer like in a rails situation 
+require File.expand_path("../../spec/dummy/config/initializers/patriarch", __FILE__)
 
 class Monster
   attr_reader :id
@@ -105,13 +109,43 @@ class FallenAngel
   end
 end
 
+class LoveLetter
+  attr_reader :id
+  
+  class << self 
+    attr_accessor :count, :object_mapping
+  end
+
+  self.count = 1
+  self.object_mapping = {}
+  
+  def initialize
+    @id = self.class.count
+    self.class.count += 1
+    self.class.object_mapping.merge!({@id => self.object_id})
+  end
+
+  def self.find(ids)
+    ids = Array(ids)
+    result = []
+    ids.each do |id|
+      object_ref = self.object_mapping[id]
+      record = ObjectSpace._id2ref(object_ref)
+      result << record unless record.nil?
+    end
+    result
+  end
+end
+
 Monster.send(:include,Patriarch::Behaviours)
 FallenAngel.send(:include,Patriarch::Behaviours)
+LoveLetter.send(:include,Patriarch::Behaviours)
 
-def new_monster
-  Monster.new
-end
+Monster.add_behaviour       :like, :on => [:fallenAngel] 
+Monster.add_behaviour       :lure, :by => [:fallenAngel]
+FallenAngel.add_behaviour   :like, :by => [:monster]
+FallenAngel.add_behaviour   :lure, :on => [:monster]
 
-def new_fallen_angel
-  FallenAngel.new
-end
+LoveLetter.add_behaviour  :praise, :medium_between => [:monster,:fallenAngel]
+Monster.add_behaviour     :praise, :on => [:fallenAngel], :via => [:LoveLetter]
+FallenAngel.add_behaviour :praise, :by => [:monster], :via => [:LoveLetter]