pickle 0.2.12 → 0.3.0

data/spec/pickle/email_spec.rb

@@ -13,22 +13,25 @@ describe Pickle::Email do
     @email1 = mock("Email 1")
     @email2 = mock("Email 2")
     ActionMailer::Base.stub!(:deliveries).and_return([@email1, @email2])
+    if defined?(ActiveRecord::Base)
+      ActiveRecord::Base::PickleAdapter.stub!(:model_classes).and_return([])
+    end
   end
-  
+
   describe "#emails" do
     it "should return ordered deliveries" do
       emails.should == [@email1, @email2]
     end
-    
+
     describe "(after)" do
       before do
         emails
       end
-      
+
       it "#email('the email') should return the last delivery" do
         email('the email').should == @email2
       end
-      
+
       it "#email('the 1st email') should return the first delivery" do
         email('the 1st email').should == @email1
       end
@@ -40,36 +43,36 @@ describe Pickle::Email do
       it "#email('the 2nd email') should return the second delivery" do
         email('the 2nd email').should == @email2
       end
-      
+
       it "#email('the last email') should return the second delivery" do
         email('the last email').should == @email2
       end
-      
+
       it "#email2('the 3rd email') should be nil" do
         email('the 3rd email').should == nil
       end
     end
-    
+
     describe "when email1 is to fred & joe, and email2 is to joe" do
       before do
         @email1.stub!(:to).and_return(['fred@gmail.com', 'joe@gmail.com'])
         @email2.stub!(:to).and_return('joe@gmail.com')
       end
-      
+
       it "#emails('to: \"fred@gmail.com\"') should just return email1" do
         emails('to: "fred@gmail.com"').should == [@email1]
       end
-      
+
       describe "after #emails('to: \"fred@gmail.com\"')" do
         before do
           emails('to: "fred@gmail.com"')
         end
-        
+
         it "#email('first') should be #email('last')" do
           email('first email').should == email('last email')
           email('first email').should == @email1
         end
-        
+
         it "#email('the email', 'to: \"blah\") should be nil" do
           email('the email', 'to: "blah"').should == nil
         end
@@ -78,28 +81,28 @@ describe Pickle::Email do
           email('the email', 'to: "fred@gmail.com"').should == @email1
         end
       end
-      
+
       it "#emails('to: \"joe@gmail.com\"') should return both emails" do
         emails('to: "joe@gmail.com"').should == [@email1, @email2]
       end
-      
+
       describe "and emails have subjects 'email1', 'email2'" do
         before do
           @email1.stub!(:subject).and_return('email1')
           @email2.stub!(:subject).and_return('email2')
         end
-        
+
         it "#emails('to: \"joe@gmail.com\", subject: \"email1\"') should return email1" do
           emails('to: "joe@gmail.com", subject: "email1"').should == [@email1]
         end
-        
+
         it "#emails('to: \"fred@gmail.com\", subject: \"email2\"') should return empty array" do
           emails('to: "fred@gmail.com", subject: "email2"').should == []
         end
       end
     end
   end
-  
+
   describe "#save_and_open_emails" do
     before do
       stub!(:open_in_browser)
@@ -107,21 +110,21 @@ describe Pickle::Email do
       @now = "2008-01-01".to_time
       Time.stub!(:now).and_return(@now)
     end
-    
+
     it "should call #emails to get emails" do
       should_receive(:emails).and_return([])
       save_and_open_emails
     end
-    
+
     describe "when emails have been already been found" do
       before { @emails = [] }
-      
+
       it "should not call #emails" do
         should_not_receive(:emails)
         save_and_open_emails
       end
     end
-    
+
     it "should create a file in Rails/tmp with the emails in it" do
       save_and_open_emails
       File.read("pickle-email-#{@now.to_i}.html").should == "<h1>Email 1</h1><pre>Contents of Email 1</pre><hr />"
@@ -132,13 +135,13 @@ describe Pickle::Email do
       save_and_open_emails
     end
   end
-  
+
   describe "following links in emails" do
     before do
       stub!(:open_in_browser)
       @email1.stub!(:body).and_return('some text <a href="http://example.com/page">example page</a> more text')
     end
-    
+
     it "should find a link for http://example.com/page" do
       should_receive(:visit).with('/page')
       visit_in_email(@email1, 'http://example.com/page')
@@ -148,7 +151,7 @@ describe Pickle::Email do
       should_receive(:visit).with('/page')
       visit_in_email(@email1, 'example page')
     end
-    
+
     it "should follow the first link in an email" do
       should_receive(:visit).with('/page')
       click_first_link_in_email(@email1)

data/spec/pickle/session_spec.rb

@@ -3,12 +3,17 @@ require File.dirname(__FILE__) + '/../spec_helper'
 # TODO: remove this and push AR stuff into ORM adapter
 module ActiveRecord
   class Base
-  end 
+  end
+end
+
+module DataMapper
+  class Model
+  end
 end
 
 describe Pickle::Session do
   include Pickle::Session
-  
+
   let :user_class do
     mock("User class", :name => 'User')
   end
@@ -16,15 +21,15 @@ describe Pickle::Session do
   let :user do
     mock("user", :class => user_class, :id => 1)
   end
-  
+
   let :user_factory do
     Pickle::Adapter::ActiveRecord.new(user_class)
   end
-  
+
   before do
     config.stub(:factories).and_return('user' => user_factory)
   end
-  
+
   describe "Pickle::Session proxy missing methods to parser", :shared => true do
     it "should forward to pickle_parser it responds_to them" do
       subject.pickle_parser.should_receive(:parse_model)
@@ -40,17 +45,17 @@ describe Pickle::Session do
     subject do
       self
     end
-    
+
     it_should_behave_like "Pickle::Session proxy missing methods to parser"
   end
 
   describe "extending Pickle::Session" do
-    subject do 
+    subject do
       returning Object.new do |object|
         object.extend Pickle::Session
       end
     end
-    
+
     it_should_behave_like "Pickle::Session proxy missing methods to parser"
   end
 
@@ -81,13 +86,13 @@ describe Pickle::Session do
       end
 
       before do
-        user_class.should_receive(:find).with(100).and_return(user_from_db)
+        Pickle::Adapter.stub!(:get_model).with(user_class, 100).and_return(user_from_db)
       end
-    
+
       it "models('user') should be array containing user" do
         models('user').should == [user_from_db]
       end
-  
+
       describe "user should be retrievable with" do
         it "model('the user')" do
           model('the user').should == user_from_db
@@ -100,79 +105,79 @@ describe Pickle::Session do
         it "model('last user')" do
           model('last user').should == user_from_db
         end
-        
+
         it "model!('last user')" do
           model('last user').should == user_from_db
         end
       end
     end
   end
-  
+
   describe "#create_model" do
     before do
       user_factory.stub!(:create).and_return(user)
     end
-    
+
     describe "('a user')" do
       it "should call user_factory.create({})" do
         user_factory.should_receive(:create).with({})
         create_model('a user')
       end
-      
+
       describe "after create," do
         before { create_model('a user') }
-        
+
         it_should_behave_like "after storing a single user"
       end
     end
-    
+
     describe "('1 user', 'foo: \"bar\", baz: \"bing bong\"')" do
       it "should call user_factory.create({'foo' => 'bar', 'baz' => 'bing bong'})" do
         user_factory.should_receive(:create).with({'foo' => 'bar', 'baz' => 'bing bong'})
         create_model('1 user', 'foo: "bar", baz: "bing bong"')
       end
-      
+
       describe "after create," do
         before { create_model('1 user', 'foo: "bar", baz: "bing bong"') }
-        
+
         it_should_behave_like "after storing a single user"
       end
-    end  
+    end
 
     describe "('an user: \"fred\")" do
       it "should call user_factory.create({})" do
         user_factory.should_receive(:create).with({})
         create_model('an user: "fred"')
       end
-      
+
       describe "after create," do
         before { create_model('an user: "fred"') }
-        
+
         it_should_behave_like "after storing a single user"
-              
+
         it "created_model('the user: \"fred\"') should retrieve the user" do
           created_model('the user: "fred"').should == user
         end
-      
+
         it "created_model?('the user: \"shirl\"') should be false" do
           created_model?('the user: "shirl"').should == false
         end
-        
+
         it "model?('the user: \"shirl\"') should be false" do
           model?('the user: "shirl"').should == false
         end
       end
     end
-    
+
     describe "with hash" do
       it "should call user_factory.create({'foo' => 'bar'})" do
         user_factory.should_receive(:create).with({'foo' => 'bar'})
-        create_model('a user', {'foo' => 'bar'})
+        create_model('a user', {'foo' => 'bar'}).should == user
       end
-      
+
       describe "after create," do
         before { create_model('a user', {'foo' => 'bar'}) }
-        
+
         it_should_behave_like "after storing a single user"
       end
     end
@@ -180,64 +185,62 @@ describe Pickle::Session do
 
   describe '#find_model' do
     before do
-      user_class.stub!(:find).and_return(user)
+      Pickle::Adapter.stub!(:find_first_model).with(user_class, anything).and_return(user)
     end
-    
+
     it "should call user_class.find :first, :conditions => {<fields>}" do
-      user_class.should_receive(:find).with(:first, :conditions => {'hair' => 'pink'})
-      find_model('a user', 'hair: "pink"')
+      find_model('a user', 'hair: "pink"').should == user
     end
-    
+
     describe "after find," do
       before { find_model('a user', 'hair: "pink"') }
-      
+
       it_should_behave_like "after storing a single user"
     end
-    
+
     describe "with hash" do
       it "should call user_class.find('user', {'foo' => 'bar'})" do
-        user_class.should_receive(:find).with(:first, :conditions => {'foo' => 'bar'})
         find_model('a user', {'foo' => 'bar'})
       end
-      
+
       describe "after find," do
         before { find_model('a user', {'foo' => 'bar'}) }
-        
+
         it_should_behave_like "after storing a single user"
       end
     end
   end
-  
+
   describe "create and find using plural_factory and table" do
     context "when given a table without a matching pickle ref column" do
       let :table do
         mock(:hashes => [{'name' => 'Fred'}, {'name' => 'Betty'}])
       end
-      
+
       it "#create_models_from_table(<plural factory>, <table>) should call create_model for each of the table hashes with plain factory name and return the models" do
         should_receive(:create_model).with("user", 'name' => "Fred").once.ordered.and_return(:fred)
         should_receive(:create_model).with("user", 'name' => "Betty").once.ordered.and_return(:betty)
         create_models_from_table("users", table).should == [:fred, :betty]
       end
-      
+
       it "#find_models_from_table(<plural factory>, <table>) should call find_model for each of the table hashes with plain factory name and return the models" do
         should_receive(:find_model).with("user", 'name' => "Fred").once.ordered.and_return(:fred)
         should_receive(:find_model).with("user", 'name' => "Betty").once.ordered.and_return(:betty)
         find_models_from_table("users", table).should == [:fred, :betty]
       end
     end
-    
+
     context "when given a table with a matching pickle ref column" do
       let :table do
         mock(:hashes => [{'user' => "fred", 'name' => 'Fred'}, {'user' => "betty", 'name' => 'Betty'}])
       end
-      
+
       it "#create_models_from_table(<plural factory>, <table>) should call create_model for each of the table hashes with labelled pickle ref" do
         should_receive(:create_model).with("user \"fred\"", 'name' => "Fred").once.ordered.and_return(:fred)
         should_receive(:create_model).with("user \"betty\"", 'name' => "Betty").once.ordered.and_return(:betty)
         create_models_from_table("users", table).should == [:fred, :betty]
       end
-      
+
       it "#find_models_from_table(<plural factory>, <table>) should call find_model for each of the table hashes with labelled pickle ref" do
         should_receive(:find_model).with("user \"fred\"", 'name' => "Fred").once.ordered.and_return(:fred)
         should_receive(:find_model).with("user \"betty\"", 'name' => "Betty").once.ordered.and_return(:betty)
@@ -245,7 +248,7 @@ describe Pickle::Session do
       end
     end
   end
-  
+
   describe "#find_model!" do
     it "should call find_model" do
       should_receive(:find_model).with('name', 'fields').and_return(user)
@@ -257,14 +260,13 @@ describe Pickle::Session do
       lambda { find_model!('name', 'fields') }.should raise_error(RuntimeError, "Can't find pickle model: 'name' in this scenario")
     end
   end
-  
+
   describe "#find_models" do
     before do
-      user_class.stub!(:find).and_return([user])
+      Pickle::Adapter.stub!(:find_all_models).with(user_class, anything).and_return([user])
     end
 
     it "should call User.find :all, :conditions => {'hair' => 'pink'}" do
-      user_class.should_receive(:find).with(:all, :conditions => {'hair' => 'pink'})
       find_models('user', 'hair: "pink"')
     end
 
@@ -274,47 +276,47 @@ describe Pickle::Session do
       it_should_behave_like "after storing a single user"
     end
   end
-    
+
   describe 'creating \'a super admin: "fred"\', then \'a user: "shirl"\', \'then 1 super_admin\' (super_admin is factory that returns users)' do
     let(:fred) { mock("fred", :class => user_class, :id => 2) }
     let(:shirl) { mock("shirl", :class => user_class, :id => 3) }
     let(:noname) { mock("noname", :class => user_class, :is => 4) }
-    
+
     let(:super_admin_factory) do
       Pickle::Adapter::FactoryGirl.new(mock(:build_class => user_class, :factory_name => :super_admin))
     end
-    
+
     before do
       config.stub(:factories).and_return(user_factory.name => user_factory, super_admin_factory.name => super_admin_factory)
       user_factory.stub(:create).and_return(shirl)
       super_admin_factory.stub(:create).and_return(fred, noname)
     end
-    
+
     def do_create_users
       create_model('a super admin: "fred"')
       create_model('a user: "shirl"')
       create_model('1 super_admin')
     end
-    
+
     it "should call Factory.create with <'super_admin'>, <'user'>, <'super_admin'>" do
       super_admin_factory.should_receive(:create).with({}).twice
       user_factory.should_receive(:create).with({}).once
       do_create_users
     end
-    
+
     describe "after create," do
       before do
         do_create_users
       end
-      
+
       it "created_models('user') should == [fred, shirl, noname]" do
         created_models('user').should == [fred, shirl, noname]
       end
-      
+
       it "created_models('super_admin') should == [fred, noname]" do
         created_models('super_admin').should == [fred, noname]
       end
-      
+
       describe "#created_model" do
         it "'that user' should be noname (the last user created - as super_admins are users)" do
           created_model('that user').should == noname
@@ -323,27 +325,27 @@ describe Pickle::Session do
         it "'the super admin' should be noname (the last super admin created)" do
           created_model('that super admin').should == noname
         end
-        
+
         it "'the 1st super admin' should be fred" do
           created_model('the 1st super admin').should == fred
         end
-        
+
         it "'the first user' should be fred" do
           created_model('the first user').should == fred
         end
-        
+
         it "'the 2nd user' should be shirl" do
           created_model('the 2nd user').should == shirl
         end
-        
+
         it "'the last user' should be noname" do
           created_model('the last user').should == noname
         end
-        
+
         it "'the user: \"fred\" should be fred" do
           created_model('the user: "fred"').should == fred
         end
-        
+
         it "'the user: \"shirl\" should be shirl" do
           created_model('the user: "shirl"').should == shirl
         end
@@ -355,11 +357,11 @@ describe Pickle::Session do
     before do
       self.pickle_parser = Pickle::Parser.new(:config => Pickle::Config.new {|c| c.map 'I', 'myself', :to => 'user: "me"'})
       config.stub(:factories).and_return('user' => user_factory)
-      user_class.stub!(:find).and_return(user)
+      Pickle::Adapter.stub!(:get_model).with(user_class, anything).and_return(user)
       user_factory.stub!(:create).and_return(user)
       create_model('the user: "me"')
     end
-  
+
     it 'model("I") should return the user' do
       model('I').should == user
     end
@@ -367,11 +369,11 @@ describe Pickle::Session do
     it 'model("myself") should return the user' do
       model('myself').should == user
     end
-    
+
     it "#parser.parse_fields 'author: user \"JIM\"' should raise Error, as model deos not refer" do
       lambda { pickle_parser.parse_fields('author: user "JIM"') }.should raise_error
     end
-    
+
     it "#parser.parse_fields 'author: the user' should return {\"author\" => <user>}" do
       pickle_parser.parse_fields('author: the user').should == {"author" => user}
     end
@@ -379,34 +381,34 @@ describe Pickle::Session do
     it "#parser.parse_fields 'author: myself' should return {\"author\" => <user>}" do
       pickle_parser.parse_fields('author: myself').should == {"author" => user}
     end
-    
+
     it "#parser.parse_fields 'author: the user, approver: I, rating: \"5\"' should return {'author' => <user>, 'approver' => <user>, 'rating' => '5'}" do
       pickle_parser.parse_fields('author: the user, approver: I, rating: "5"').should == {'author' => user, 'approver' => user, 'rating' => '5'}
     end
-    
+
     it "#parser.parse_fields 'author: user: \"me\", approver: \"\"' should return {'author' => <user>, 'approver' => \"\"}" do
       pickle_parser.parse_fields('author: user: "me", approver: ""').should == {'author' => user, 'approver' => ""}
     end
   end
-  
+
   describe "convert_models_to_attributes(ar_class, :user => <a user>)" do
     before do
       user.stub(:is_a?).with(ActiveRecord::Base).and_return(true)
     end
-    
+
     describe "(when ar_class has column 'user_id')" do
       let :ar_class do
-        mock('ActiveRecord', :column_names => ['user_id'])
+        mock('ActiveRecord', :column_names => ['user_id'], :const_get => ActiveRecord::Base::PickleAdapter)
       end
-      
+
       it "should return {'user_id' => <the user.id>}" do
         convert_models_to_attributes(ar_class, :user => user).should == {'user_id' => user.id}
       end
     end
-    
+
     describe "(when ar_class has columns 'user_id', 'user_type')" do
       let :ar_class do
-        mock('ActiveRecord', :column_names => ['user_id', 'user_type'])
+        mock('ActiveRecord', :column_names => ['user_id', 'user_type'], :const_get => ActiveRecord::Base::PickleAdapter)
       end
             
       it "should return {'user_id' => <the user.id>, 'user_type' => <the user.base_class>}" do
@@ -415,7 +417,7 @@ describe Pickle::Session do
       end
     end
   end
-  
+
   it "#model!('unknown') should raise informative error message" do
     lambda { model!('unknown') }.should raise_error("Can't find pickle model: 'unknown' in this scenario")
   end
@@ -423,4 +425,4 @@ describe Pickle::Session do
   it "#created_model!('unknown') should raise informative error message" do
     lambda { created_model!('unknown') }.should raise_error("Can't find pickle model: 'unknown' in this scenario")
   end
-end
+end