pickle 0.1.16

data/spec/lib/pickle_email_spec.rb

@@ -0,0 +1,131 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Email do
+  include Pickle::Session
+  include Pickle::Email
+  include Pickle::Email::Parser
+
+  before do
+    @email1 = mock("Email 1")
+    @email2 = mock("Email 2")
+    ActionMailer::Base.stub!(:deliveries).and_return([@email1, @email2])
+  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
+
+      it "#email('the first email') should return the first delivery" do
+        email('the first email').should == @email1
+      end
+
+      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
+
+        it "#email('the email', 'to: \"fred@gmail.com\") should be email1" 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)
+      stub!(:emails).and_return(["Contents of Email 1"])
+      @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("#{RAILS_ROOT}/tmp/webrat-email-#{@now.to_i}.html").should == "<h1>Email 1</h1><pre>Contents of Email 1</pre><hr />"
+    end
+
+    it "should call open_in_browser on created tmp file" do
+      should_receive(:open_in_browser).with("#{RAILS_ROOT}/tmp/webrat-email-#{@now.to_i}.html")
+      save_and_open_emails
+    end
+  end
+end

data/spec/lib/pickle_parser_matchers_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Parser::Matchers do
+  include Pickle::Parser::Matchers
+
+  describe "(config: [factories: user, car, fast_car] [predicates: name, status, fancy?, super_fancy?]" do
+    def config
+      @config ||= Pickle::Config.new do |c|
+        c.factories = {
+          'user'      => mock('factory'),
+          'car'       => mock('factory'),
+          'fast_car'  => mock('factory')
+        }
+        c.predicates = %w(name status fancy? super_fancy?)
+      end
+    end
+  
+    describe "Match atoms" do
+      def self.atom_should_match(atom, strings)
+        Array(strings).each do |string|
+          it "#{atom} should match '#{string}'" do
+            string.should match(/^#{send atom}$/)
+          end
+        end
+      end
+
+      def self.atom_should_not_match(atom, strings)
+        Array(strings).each do |string|
+          it "#{atom} should NOT match '#{string}'" do
+            string.should_not match(/^#{send atom}$/)
+          end
+        end
+      end
+  
+      atom_should_match     :match_ordinal, ['1st', '2nd', '23rd', '104th']
+      atom_should_not_match :match_ordinal, ['1', '2']
+
+      atom_should_match     :match_index, ['first', 'last', '23rd', '104th']
+      atom_should_not_match :match_index, ['1', '2', 'foo']
+
+      atom_should_match     :match_label, [': "gday"', ': "gday mate"']
+      atom_should_not_match :match_label, [': "gday""', ': gday']
+  
+      atom_should_match     :match_field, ['foo: "this is the life"', 'bar_man: "and so is this"', 'boolean: false', 'boolean: true', 'numeric: 10', 'numeric: 12.5']
+      atom_should_not_match :match_field, ['foo bar: "this aint workin"']
+  
+      atom_should_match     :match_fields, ['foo: "bar"', 'foo: "bar", baz: "bah"']
+      atom_should_not_match :match_fields, ['foo bar: "baz"', 'email: "a", password: "b", and password_confirmation: "c"']
+
+      atom_should_match     :match_model, ['a user', '1st fast car', 'the 23rd fast_car', 'the user: "fred flinstone"']
+      atom_should_not_match :match_model, ['a giraffe', 'a 1st faster car: "jim"', 'an event created']
+  
+      atom_should_match     :match_predicate, ['name', 'status', 'fancy', 'super fancy', 'super_fancy']
+      atom_should_not_match :match_predicate, ['nameo', 'increment', 'not a predicate']
+    
+      atom_should_match     :match_factory, ['user', 'fast car', 'fast_car', 'car']
+      atom_should_not_match :match_factory, ['users', 'faster car', 'event created']
+    
+      atom_should_match     :match_plural_factory, ['users', 'fast cars']
+      atom_should_not_match :match_plural_factory, ['usereres', 'fasts cars']
+    end
+  end
+  
+  describe "capture methods" do
+    it "capture_field should == '(' + match_field + ')'" do
+      should_receive(:match_field).and_return('MATCH_FIELD')
+      capture_field.should == '(MATCH_FIELD)'
+    end
+  end
+end

data/spec/lib/pickle_parser_spec.rb

@@ -0,0 +1,154 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Parser do
+  before do
+    @parser = Pickle::Parser.new(:config => Pickle::Config.new)
+  end
+  
+  it "should raise error when created with no config" do
+    lambda{ Pickle::Parser.new }.should raise_error(ArgumentError)
+  end
+  
+  describe 'misc regexps' do
+    describe '/^#{capture_model} exists/' do
+      before do
+        @regexp = /^(#{@parser.capture_model}) exists$/
+      end
+      
+      it "should match 'a user exists'" do
+        'a user exists'.should match(@regexp)
+      end
+      
+      it "should caputure 'a user' from  'a user exists'" do
+        'a user exists'.match(@regexp)[1].should == 'a user'
+      end
+    end
+  end
+  
+  describe '#parse_field' do
+    it "should return {'a' => 'b'} for 'a: \"b\"'" do
+      @parser.parse_field('a: "b"').should == {'a' => 'b'}
+    end
+  
+    it "should raise error for invalid field 'a : b'" do
+      lambda { @parser.parse_field('a : b') }.should raise_error(ArgumentError)
+    end
+  end
+  
+  describe '#parse_fields' do
+    it 'should return {} for blank argument' do
+      @parser.parse_fields(nil).should == {}
+      @parser.parse_fields('').should == {}
+    end
+    
+    it 'should raise error for invalid argument' do
+      lambda { @parser.parse_fields('foo foo') }.should raise_error(ArgumentError)
+    end
+    
+    it '(\'foo: "bar"\') should == { "foo" => "bar"}' do
+      @parser.parse_fields('foo: "bar"').should == { "foo" => "bar"}
+    end
+    
+    it '("bool: true") should == { "bool" => true}' do
+      @parser.parse_fields('bool: true').should == {"bool" => true}
+    end
+    
+    it '("bool: false") should == { "bool" => false}' do
+      @parser.parse_fields('bool: false').should == {"bool" => false}
+    end
+    
+    it '("int: 10") should == { "int" => 10 }' do
+      @parser.parse_fields('int: 10').should == {"int" => 10}
+    end
+
+    it '("float: 10.1") should == { "float" => 10.1 }' do
+      @parser.parse_fields('float: 10.1').should == {"float" => 10.1}
+    end
+
+    it '(\'foo: "bar", bar_man: "wonga wonga", gump: 123\') should == {"foo" => "bar", "bar_man" => "wonga wonga", "gump" => 123}' do
+      @parser.parse_fields('foo: "bar", bar_man: "wonga wonga", gump: 123').should == {"foo" => "bar", "bar_man" => "wonga wonga", "gump" => 123}
+    end
+  end
+  
+  describe '#parse_model' do
+    it '("a user") should == ["user", ""]' do
+      @parser.parse_model("a user").should == ["user", ""]
+    end
+  
+    it '("the user") should == ["user", ""]' do
+      @parser.parse_model("the user").should == ["user", ""]
+    end
+  
+    it '("1 fast car") should == ["fast_car", ""]' do
+      @parser.parse_model("1 fast car").should == ["fast_car", ""]
+    end
+    
+    it '(\'an user: "jim jones"\') should == ["user", "jim_jones"]' do
+      @parser.parse_model('an user: "jim jones"').should == ["user", "jim_jones"]
+    end
+    
+    it '(\'that fast car: "herbie"\') should == ["fast_car", "herbie"]' do
+      @parser.parse_model('that fast car: "herbie"').should == ["fast_car", "herbie"]
+    end
+    
+    it '(\'the 12th user\') should == ["user", 11]' do
+      @parser.parse_model('the 12th user').should == ["user", 11]
+    end
+  
+    it '(\'the last user\') should == ["user", -1]' do
+      @parser.parse_model('the last user').should == ["user", -1]
+    end
+    
+    it '("the first user") should == ["user", 0]' do
+      @parser.parse_model('the first user').should == ["user", 0]
+    end
+  
+    it '("the 1st user") should == ["user", 0]' do
+      @parser.parse_model('the 1st user').should == ["user", 0]
+    end
+  end
+  
+  describe "#parse_index" do
+    it '("1st") should == 0' do
+      @parser.parse_index("1st").should == 0
+    end
+  
+    it '("24th") should == 23' do
+      @parser.parse_index("24th").should == 23
+    end
+    it '("first") should == 0' do
+      @parser.parse_index("first").should == 0
+    end
+    
+    it '("last") should == -1' do
+      @parser.parse_index("last").should == -1
+    end
+  end
+  
+  describe "customised mappings" do
+    describe "config maps 'I|myself' to 'user: \"me\"'" do
+      before do
+        @config = Pickle::Config.new do |c|
+          c.map 'I', 'myself', :to => 'user: "me"'
+        end
+        @parser = Pickle::Parser.new(:config => @config)
+      end
+
+      it "'I' should match /\#{match_model}/" do
+        'I'.should match(/#{@parser.match_model}/)
+      end
+    
+      it "'myself' should match /\#{match_model}/" do
+        'myself'.should match(/#{@parser.match_model}/)
+      end
+    
+      it "parse_model('I') should == ['user', 'me']" do
+        @parser.parse_model('I').should == ["user", "me"]
+      end
+
+      it "parse_model('myself') should == ['user', 'me']" do
+        @parser.parse_model('myself').should == ["user", "me"]
+      end
+    end
+  end
+end

data/spec/lib/pickle_path_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Path do
+  include Pickle::Path
+  
+  describe "#path_to_pickle, when the model doesn't exist" do
+    before do
+      stub!(:model!).and_raise("foo")
+    end
+    it "('that user', :extra => 'new comment') should raise the error raised by model!" do
+      lambda { path_to_pickle "that user", "new comment" }.should raise_error("foo")
+    end
+    
+  end
+  
+  describe "#path_to_pickle" do
+    before do
+      stub!(:model!).and_return(@user = mock_model(User))
+    end
+    it "('a user', 'the user: \"fred\"') should retrieve 'a user', and 'the user: \"fred\"' models" do
+      should_receive(:model!).with('a user')
+      should_receive(:model!).with('the user: "fred"')
+      stub!(:user_user_path).and_return('the path')
+      path_to_pickle 'a user', 'the user: "fred"'
+    end
+    
+    it "('a user', :action => 'foo') should return foo_user_path(<user>)" do
+      should_receive(:foo_user_path).with(@user).and_return('the path')
+      path_to_pickle('a user', :action => 'foo').should == 'the path'
+    end
+    
+    it "('a user', :action => 'foo') should raise informative error if foo_user_path not defined" do
+      should_receive(:foo_user_path).with(@user).and_raise(NoMethodError)
+      lambda { path_to_pickle('a user', :action => 'foo') }.should raise_error(Exception, /Could not figure out a path for/)
+    end
+    
+    it "('a user', :segment => 'foo') should return user_foo_path(<user>)" do
+      should_receive(:user_foo_path).with(@user).and_return('the path')
+      path_to_pickle('a user', :segment => 'foo').should == 'the path'
+    end
+    
+    it "('a user', :segment => 'foo') should raise informative error if foo_user_path not defined" do
+      should_receive(:user_foo_path).with(@user).and_raise(NoMethodError)
+      lambda { path_to_pickle('a user', :segment => 'foo') }.should raise_error(Exception, /Could not figure out a path for/)
+    end
+    
+    it "('a user', :action => 'new', :segment => 'comment') should return new_user_comment_path(<user>)" do
+      should_receive(:new_user_comment_path).with(@user).and_return('the path')
+      path_to_pickle('a user', :segment => 'comment', :action => 'new').should == 'the path'
+    end
+    
+    it "('a user', :action => 'new', :segment => 'comment') should raise informative error if new_user_comment_path not defined" do
+      should_receive(:new_user_comment_path).with(@user).and_raise(NoMethodError)
+      lambda { path_to_pickle('a user', :action => 'new', :segment => 'comment') }.should raise_error(Exception, /Could not figure out a path for/)
+    end
+    
+    it "('a user', :extra => 'new comment') should return new_user_comment_path(<user>)" do
+      should_receive(:new_user_comment_path).with(@user).and_return('the path')
+      path_to_pickle('a user', :extra => 'new comment').should == 'the path'
+    end
+    
+    it "('a user', :extra => 'new comment') should raise informative error if new_user_comment_path not defined" do
+      should_receive(:new_user_comment_path).with(@user).and_raise(NoMethodError)
+      lambda { path_to_pickle('a user', :extra => 'new comment') }.should raise_error(Exception, /Could not figure out a path for/)
+    end
+    
+    describe "(private API)" do
+      it "('a user', :extra => 'new ish comment') should try combinations of 'new', 'ish', 'comment'" do
+        should_receive(:pickle_path_for_models_action_segment).with([@user], '', 'new_ish_comment').once
+        should_receive(:pickle_path_for_models_action_segment).with([@user], 'new', 'ish_comment').once
+        should_receive(:pickle_path_for_models_action_segment).with([@user], 'new_ish', 'comment').once
+        should_receive(:pickle_path_for_models_action_segment).with([@user], 'new_ish_comment', '').once
+        lambda { path_to_pickle('a user', :extra => 'new ish comment') }.should raise_error(Exception, /Could not figure out a path for/)
+      end
+    end
+  end
+end

data/spec/lib/pickle_session_spec.rb

@@ -0,0 +1,337 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../spec_helper'))
+
+describe Pickle::Session do
+  include Pickle::Session
+  
+  describe "Pickle::Session proxy missing methods to parser", :shared => true do
+    it "should forward to pickle_parser it responds_to them" do
+      @it.pickle_parser.should_receive(:parse_model)
+      @it.parse_model
+    end
+
+    it "should raise error if pickle_parser don't know about em" do
+      lambda { @it.parse_infinity }.should raise_error
+    end
+  end
+
+  describe "including Pickle::Session" do
+    before do 
+      @it = self
+    end
+    
+    it_should_behave_like "Pickle::Session proxy missing methods to parser"
+  end
+
+  describe "extending Pickle::Session" do
+    before do 
+      @it = Object.new
+      @it.extend Pickle::Session
+    end
+    
+    it_should_behave_like "Pickle::Session proxy missing methods to parser"
+  end
+
+  describe "after storing a single user", :shared => true do
+    it "created_models('user') should be array containing the original user" do
+      created_models('user').should == [@user]
+    end
+
+    describe "the original user should be retrievable with" do
+      it "created_model('the user')" do
+        created_model('the user').should == @user
+      end
+
+      it "created_model('1st user')" do
+        created_model('1st user').should == @user
+      end
+
+      it "created_model('last user')" do
+        created_model('last user').should == @user
+      end
+    end
+
+    describe "(found from db)" do
+      before do
+        @user.stub!(:id).and_return(100)
+        @user.class.should_receive(:find).with(100).and_return(@user_from_db = @user.dup)
+      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
+        end
+
+        it "model('1st user')" do
+          model('1st user').should == @user_from_db
+        end
+
+        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 = mock_model(User)
+      Factory.stub!(:create).and_return(@user)
+    end
+    
+    describe "('a user')" do
+      def do_create_model
+        create_model('a user')
+      end
+  
+      it "should call Factory.create('user', {})" do
+        Factory.should_receive(:create).with('user', {}).and_return(@user)
+        do_create_model
+      end
+      
+      describe "after create," do
+        before { do_create_model }
+        
+        it_should_behave_like "after storing a single user"
+      end
+    end
+    
+    describe "('1 user', 'foo: \"bar\", baz: \"bing bong\"')" do
+      def do_create_model
+        create_model('1 user', 'foo: "bar", baz: "bing bong"')
+      end
+  
+      it "should call Factory.create('user', {'foo' => 'bar', 'baz' => 'bing bong'})" do
+        Factory.should_receive(:create).with('user', {'foo' => 'bar', 'baz' => 'bing bong'}).and_return(@user)
+        do_create_model
+      end
+      
+      describe "after create," do
+        before { do_create_model }
+        
+        it_should_behave_like "after storing a single user"
+      end
+    end  
+
+    describe "('an user: \"fred\")" do
+      def do_create_model
+        create_model('an user: "fred"')
+      end
+  
+      it "should call Factory.create('user', {})" do
+        Factory.should_receive(:create).with('user', {}).and_return(@user)
+        do_create_model
+      end
+      
+      describe "after create," do
+        before { do_create_model }
+        
+        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  
+  end
+
+  describe '#find_model' do
+    before do
+      @user = mock_model(User)
+      User.stub!(:find).and_return(@user)
+    end
+    
+    def do_find_model
+      find_model('a user', 'hair: "pink"')
+    end
+    
+    it "should call User.find :first, :conditions => {'hair' => 'pink'}" do
+      User.should_receive(:find).with(:first, :conditions => {'hair' => 'pink'}).and_return(@user)
+      do_find_model
+    end
+    
+    describe "after find," do
+      before { do_find_model }
+      
+      it_should_behave_like "after storing a single user"
+    end
+  end
+  
+  describe "#find_models" do
+    before do
+      @user = mock_model(User)
+      User.stub!(:find).and_return([@user])
+    end
+
+    def do_find_models
+      find_models('user', 'hair: "pink"')
+    end
+
+    it "should call User.find :all, :conditions => {'hair' => 'pink'}" do
+      User.should_receive(:find).with(:all, :conditions => {'hair' => 'pink'}).and_return([@user])
+      do_find_models
+    end
+
+    describe "after find," do
+      before { do_find_models }
+
+      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\'' do
+    before do
+      @user = @fred = mock_model(User)
+      @shirl  = mock_model(User)
+      @noname = mock_model(User)
+      Factory.stub!(:create).and_return(@fred, @shirl, @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
+      Factory.should_receive(:create).with('super_admin', {}).twice
+      Factory.should_receive(:create).with('user', {}).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
+        end
+
+        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
+      end
+    end
+  end
+
+  describe "when 'the user: \"me\"' exists and there is a mapping from 'I', 'myself' => 'user: \"me\"" do
+    before do
+      @user = mock_model(User)
+      User.stub!(:find).and_return(@user)
+      Factory.stub!(:create).and_return(@user)
+      self.pickle_parser = Pickle::Parser.new(:config => Pickle::Config.new {|c| c.map 'I', 'myself', :to => 'user: "me"'})
+      create_model('the user: "me"')
+    end
+  
+    it 'model("I") should return the user' do
+      model('I').should == @user
+    end
+
+    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
+
+    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 = mock_model(User)
+    end
+    
+    describe "(when ar_class has column 'user_id')" do
+      before do
+        @ar_class = mock('ActiveRecord', :column_names => ['user_id'])
+      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
+      before do
+        @ar_class = mock('ActiveRecord', :column_names => ['user_id', 'user_type'])
+      end
+      
+      it "should return {'user_id' => <the user.id>, 'user_type' => <the user.type>}" do
+        convert_models_to_attributes(@ar_class, :user => @user).should == {'user_id' => @user.id, 'user_type' => @user.class.name}
+      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
+
+  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