pickle 0.4.11 → 0.5.0

data/spec/pickle/parser/matchers_spec.rb

@@ -7,9 +7,9 @@ describe Pickle::Parser::Matchers do
     def config
       @config ||= Pickle::Config.new do |c|
         c.factories = {
-          'user'      => mock('factory'),
-          'car'       => mock('factory'),
-          'fast_car'  => mock('factory')
+          'user'      => double('factory'),
+          'car'       => double('factory'),
+          'fast_car'  => double('factory')
         }
         c.predicates = %w(name status fancy? super_fancy? has_style? has_super_style?)
       end
@@ -19,7 +19,7 @@ describe Pickle::Parser::Matchers do
       def self.atom_should_match(atom, strings)
         Array(strings).each do |string|
           it "#{atom} should match '#{string}'" do
-            string.should match(/^#{send atom}$/)
+            expect(string).to match(/^#{send atom}$/)
           end
         end
       end
@@ -27,7 +27,7 @@ describe Pickle::Parser::Matchers do
       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}$/)
+            expect(string).not_to match(/^#{send atom}$/)
           end
         end
       end
@@ -63,8 +63,8 @@ describe Pickle::Parser::Matchers do
   
   describe "capture methods" do
     it "capture_field should == '(' + match_field + ')'" do
-      should_receive(:match_field).and_return('MATCH_FIELD')
-      capture_field.should == '(MATCH_FIELD)'
+      expect(self).to receive(:match_field).and_return('MATCH_FIELD')
+      expect(capture_field).to eq('(MATCH_FIELD)')
     end
   end
-end
+end

data/spec/pickle/parser_spec.rb

@@ -6,12 +6,12 @@ describe Pickle::Parser do
   end
   
   it "should raise error when created with no config" do
-    lambda{ Pickle::Parser.new }.should raise_error(ArgumentError)
+    expect{ Pickle::Parser.new }.to raise_error(ArgumentError)
   end
   
   describe "when a 'user' factory exists in config" do
     before do
-      @parser.config.stub(:factories).and_return('user' => mock('User'))
+      allow(@parser.config).to receive(:factories).and_return('user' => double('User'))
     end
     
     describe 'misc regexps' do
@@ -21,116 +21,116 @@ describe Pickle::Parser do
         end
       
         it "should match 'a user exists'" do
-          'a user exists'.should match(@regexp)
+          expect('a user exists').to match(@regexp)
         end
       
         it "should caputure 'a user' from  'a user exists'" do
-          'a user exists'.match(@regexp)[1].should == 'a user'
+          expect('a user exists'.match(@regexp)[1]).to eq('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'}
+        expect(@parser.parse_field('a: "b"')).to eq({'a' => 'b'})
       end
   
       it "should raise error for invalid field 'a : b'" do
-        lambda { @parser.parse_field('a : b') }.should raise_error(ArgumentError)
+        expect { @parser.parse_field('a : b') }.to 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 == {}
+        expect(@parser.parse_fields(nil)).to eq({})
+        expect(@parser.parse_fields('')).to eq({})
       end
     
       it 'should raise error for invalid argument' do
-        lambda { @parser.parse_fields('foo foo') }.should raise_error(ArgumentError)
+        expect { @parser.parse_fields('foo foo') }.to raise_error(ArgumentError)
       end
     
       it '(\'foo: "bar"\') should == { "foo" => "bar"}' do
-        @parser.parse_fields('foo: "bar"').should == { "foo" => "bar"}
+        expect(@parser.parse_fields('foo: "bar"')).to eq({ "foo" => "bar"})
       end
 
       it '(\'foo: "something \"quoted\""\') should == { "foo" => "bar"}' do
-        @parser.parse_fields('foo: "something \"quoted\""').should == { "foo" => 'something "quoted"' }
+        expect(@parser.parse_fields('foo: "something \"quoted\""')).to eq({ "foo" => 'something "quoted"' })
       end
     
       it '("bool: true") should == { "bool" => true}' do
-        @parser.parse_fields('bool: true').should == {"bool" => true}
+        expect(@parser.parse_fields('bool: true')).to eq({"bool" => true})
       end
     
       it '("bool: false") should == { "bool" => false}' do
-        @parser.parse_fields('bool: false').should == {"bool" => false}
+        expect(@parser.parse_fields('bool: false')).to eq({"bool" => false})
       end
     
       it '("int: 10") should == { "int" => 10 }' do
-        @parser.parse_fields('int: 10').should == {"int" => 10}
+        expect(@parser.parse_fields('int: 10')).to eq({"int" => 10})
       end
 
       it '("float: 10.1") should == { "float" => 10.1 }' do
-        @parser.parse_fields('float: 10.1').should == {"float" => 10.1}
+        expect(@parser.parse_fields('float: 10.1')).to eq({"float" => 10.1})
       end
 
       it '(\'foo: "bar", bar_man: "wonga wonga", baz_woman: "one \"two\" three", gump: 123\') should == {"foo" => "bar", "bar_man" => "wonga wonga", "gump" => 123}' do
-        @parser.parse_fields('foo: "bar", bar_man: "wonga wonga", baz_woman: "one \"two\" three", gump: 123').should == {"foo" => "bar", "bar_man" => "wonga wonga", "baz_woman" => "one \"two\" three", "gump" => 123}
+        expect(@parser.parse_fields('foo: "bar", bar_man: "wonga wonga", baz_woman: "one \"two\" three", gump: 123')).to eq({"foo" => "bar", "bar_man" => "wonga wonga", "baz_woman" => "one \"two\" three", "gump" => 123})
       end
     end
   
     describe '#parse_model' do
       it '("a user") should == ["user", ""]' do
-        @parser.parse_model("a user").should == ["user", ""]
+        expect(@parser.parse_model("a user")).to eq(["user", ""])
       end
   
       it '("the user") should == ["user", ""]' do
-        @parser.parse_model("the user").should == ["user", ""]
+        expect(@parser.parse_model("the user")).to eq(["user", ""])
       end
   
       it '("1 user") should == ["user", ""]' do
-        @parser.parse_model("1 user").should == ["user", ""]
+        expect(@parser.parse_model("1 user")).to eq(["user", ""])
       end
     
       it '(\'an user: "jim jones"\') should == ["user", "jim_jones"]' do
-        @parser.parse_model('an user: "jim jones"').should == ["user", "jim_jones"]
+        expect(@parser.parse_model('an user: "jim jones"')).to eq(["user", "jim_jones"])
       end
     
       it '(\'that user: "herbie"\') should == ["user", "herbie"]' do
-        @parser.parse_model('that user: "herbie"').should == ["user", "herbie"]
+        expect(@parser.parse_model('that user: "herbie"')).to eq(["user", "herbie"])
       end
     
       it '(\'the 12th user\') should == ["user", 11]' do
-        @parser.parse_model('the 12th user').should == ["user", 11]
+        expect(@parser.parse_model('the 12th user')).to eq(["user", 11])
       end
   
       it '(\'the last user\') should == ["user", -1]' do
-        @parser.parse_model('the last user').should == ["user", -1]
+        expect(@parser.parse_model('the last user')).to eq(["user", -1])
       end
     
       it '("the first user") should == ["user", 0]' do
-        @parser.parse_model('the first user').should == ["user", 0]
+        expect(@parser.parse_model('the first user')).to eq(["user", 0])
       end
   
       it '("the 1st user") should == ["user", 0]' do
-        @parser.parse_model('the 1st user').should == ["user", 0]
+        expect(@parser.parse_model('the 1st user')).to eq(["user", 0])
       end
     end
   
     describe "#parse_index" do
       it '("1st") should == 0' do
-        @parser.parse_index("1st").should == 0
+        expect(@parser.parse_index("1st")).to eq(0)
       end
   
       it '("24th") should == 23' do
-        @parser.parse_index("24th").should == 23
+        expect(@parser.parse_index("24th")).to eq(23)
       end
       it '("first") should == 0' do
-        @parser.parse_index("first").should == 0
+        expect(@parser.parse_index("first")).to eq(0)
       end
     
       it '("last") should == -1' do
-        @parser.parse_index("last").should == -1
+        expect(@parser.parse_index("last")).to eq(-1)
       end
     end
   end
@@ -142,23 +142,23 @@ describe Pickle::Parser do
           c.map 'I', 'myself', :to => 'user: "me"'
         end
         @parser = Pickle::Parser.new(:config => @config)
-        @parser.config.stub(:factories).and_return('user' => mock('User'))
+        allow(@parser.config).to receive(:factories).and_return('user' => double('User'))
       end
 
       it "'I' should match /\#{match_model}/" do
-        'I'.should match(/#{@parser.match_model}/)
+        expect('I').to match(/#{@parser.match_model}/)
       end
   
       it "'myself' should match /\#{match_model}/" do
-        'myself'.should match(/#{@parser.match_model}/)
+        expect('myself').to match(/#{@parser.match_model}/)
       end
   
       it "parse_model('I') should == ['user', 'me']" do
-        @parser.parse_model('I').should == ["user", "me"]
+        expect(@parser.parse_model('I')).to eq(["user", "me"])
       end
 
       it "parse_model('myself') should == ['user', 'me']" do
-        @parser.parse_model('myself').should == ["user", "me"]
+        expect(@parser.parse_model('myself')).to eq(["user", "me"])
       end
     end
   end

data/spec/pickle/path_spec.rb

@@ -7,10 +7,10 @@ describe Pickle::Path do
   
   describe "#path_to_pickle, when the model doesn't exist" do
     before do
-      stub!(:model).and_return(nil)
+      allow(self).to receive(:model).and_return(nil)
     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(RuntimeError, 'Could not figure out a path for ["that user", "new comment"] {}')
+      expect { path_to_pickle "that user", "new comment" }.to raise_error(RuntimeError, 'Could not figure out a path for ["that user", "new comment"] {}')
     end
     
   end
@@ -18,82 +18,82 @@ describe Pickle::Path do
   describe "#path_to_pickle" do
     describe "when model returns a user" do
       let :user_class do
-        mock 'User', :name => 'User'
+        double 'User', :name => 'User'
       end
       
       let :user do
-        mock 'user', :class => user_class
+        double 'user', :class => user_class
       end
       
       before do
-        stub!(:model).and_return(user)
+        allow(self).to receive(:model).and_return(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"').should == 'the path'
+        expect(self).to receive(:model).with('a user')
+        expect(self).to receive(:model).with('the user: "fred"')
+        allow(self).to receive(:user_user_path).and_return('the path')
+        expect(path_to_pickle('a user', 'the user: "fred"')).to eq('the path')
       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'
+        expect(self).to receive(:foo_user_path).with(user).and_return('the path')
+        expect(path_to_pickle('a user', :action => 'foo')).to eq('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/)
+        expect(self).to receive(:foo_user_path).with(user).and_raise(NoMethodError)
+        expect { path_to_pickle('a user', :action => 'foo') }.to 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'
+        expect(self).to receive(:user_foo_path).with(user).and_return('the path')
+        expect(path_to_pickle('a user', :segment => 'foo')).to eq('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/)
+        expect(self).to receive(:user_foo_path).with(user).and_raise(NoMethodError)
+        expect { path_to_pickle('a user', :segment => 'foo') }.to 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'
+        expect(self).to receive(:new_user_comment_path).with(user).and_return('the path')
+        expect(path_to_pickle('a user', :segment => 'comment', :action => 'new')).to eq('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/)
+        expect(self).to receive(:new_user_comment_path).with(user).and_raise(NoMethodError)
+        expect { path_to_pickle('a user', :action => 'new', :segment => 'comment') }.to 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'
+        expect(self).to receive(:new_user_comment_path).with(user).and_return('the path')
+        expect(path_to_pickle('a user', :extra => 'new comment')).to eq('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/)
+        expect(self).to receive(:new_user_comment_path).with(user).and_raise(NoMethodError)
+        expect { path_to_pickle('a user', :extra => 'new comment') }.to raise_error(Exception, /Could not figure out a path for/)
       end
       
       describe "when args is a list of pickle and non pickle models" do
         before do
-          stub!(:model).with("account").and_return(nil)
+          allow(self).to receive(:model).with("account").and_return(nil)
         end
       
         it "('account', 'the user') should return account_user_path(<user>)" do
-          should_receive(:account_user_path).with(user).and_return("the path")
-          path_to_pickle('account', 'the user').should == 'the path'
+          expect(self).to receive(:account_user_path).with(user).and_return("the path")
+          expect(path_to_pickle('account', 'the user')).to eq('the path')
         end
       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_resources_action_segment).with([user], '', 'new_ish_comment').once
-          should_receive(:pickle_path_for_resources_action_segment).with([user], 'new', 'ish_comment').once
-          should_receive(:pickle_path_for_resources_action_segment).with([user], 'new_ish', 'comment').once
-          should_receive(:pickle_path_for_resources_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/)
+          expect(self).to receive(:pickle_path_for_resources_action_segment).with([user], '', 'new_ish_comment').once
+          expect(self).to receive(:pickle_path_for_resources_action_segment).with([user], 'new', 'ish_comment').once
+          expect(self).to receive(:pickle_path_for_resources_action_segment).with([user], 'new_ish', 'comment').once
+          expect(self).to receive(:pickle_path_for_resources_action_segment).with([user], 'new_ish_comment', '').once
+          expect { path_to_pickle('a user', :extra => 'new ish comment') }.to raise_error(Exception, /Could not figure out a path for/)
         end
       end
     end

data/spec/pickle/session_spec.rb

@@ -15,11 +15,11 @@ describe Pickle::Session do
   include Pickle::Session
 
   let :user_class do
-    mock("User class", :name => 'User')
+    double("User class", :name => 'User')
   end
 
   let :user do
-    mock("user", :class => user_class, :id => 1)
+    double("user", :class => user_class, :id => 100)
   end
 
   let :user_factory do
@@ -27,17 +27,17 @@ describe Pickle::Session do
   end
 
   before do
-    config.stub(:factories).and_return('user' => user_factory)
+    allow(config).to receive(:factories).and_return('user' => user_factory)
   end
 
   shared_examples_for "Pickle::Session proxy missing methods to parser" do
     it "should forward to pickle_parser it responds_to them" do
-      subject.pickle_parser.should_receive(:parse_model)
+      expect(subject.pickle_parser).to receive(:parse_model)
       subject.parse_model
     end
 
     it "should raise error if pickle_parser don't know about em" do
-      lambda { subject.parse_infinity }.should raise_error
+      expect { subject.parse_infinity }.to raise_error
     end
   end
 
@@ -59,51 +59,51 @@ describe Pickle::Session do
 
   shared_examples_for "after storing a single user" do
     it "created_models('user') should be array containing the original user" do
-      created_models('user').should == [user]
+      expect(created_models('user')).to eq([user])
     end
 
     describe "the original user should be retrievable with" do
       it "created_model('the user')" do
-        created_model('the user').should == user
+        expect(created_model('the user')).to eq(user)
       end
 
       it "created_model('1st user')" do
-        created_model('1st user').should == user
+        expect(created_model('1st user')).to eq(user)
       end
 
       it "created_model('last user')" do
-        created_model('last user').should == user
+        expect(created_model('last user')).to eq(user)
       end
     end
 
     describe "(found from db)" do
       let :user_from_db do
-        user.dup.tap {|from_db| from_db.stub!(:id).and_return(100) }
+        user.dup.tap {|from_db| allow(from_db).to receive(:id).and_return(100) }
       end
 
       before do
-        Pickle::Adapter.stub!(:get_model).with(user_class, 100).and_return(user_from_db)
+        allow(Pickle::Adapter).to receive(: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]
+        expect(models('user')).to eq([user_from_db])
       end
 
       describe "user should be retrievable with" do
         it "model('the user')" do
-          model('the user').should == user_from_db
+          expect(model('the user')).to eq(user_from_db)
         end
 
         it "model('1st user')" do
-          model('1st user').should == user_from_db
+          expect(model('1st user')).to eq(user_from_db)
         end
 
         it "model('last user')" do
-          model('last user').should == user_from_db
+          expect(model('last user')).to eq(user_from_db)
         end
 
         it "model!('last user')" do
-          model('last user').should == user_from_db
+          expect(model('last user')).to eq(user_from_db)
         end
       end
     end
@@ -111,12 +111,12 @@ describe Pickle::Session do
 
   describe "#create_model" do
     before do
-      user_factory.stub!(:create).and_return(user)
+      allow(user_factory).to receive(:create).and_return(user)
     end
 
     describe "('a user')" do
       it "should call user_factory.create({})" do
-        user_factory.should_receive(:create).with({})
+        expect(user_factory).to receive(:create).with({})
         create_model('a user')
       end
 
@@ -129,7 +129,7 @@ describe Pickle::Session do
 
     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'})
+        expect(user_factory).to receive(:create).with({'foo' => 'bar', 'baz' => 'bing bong'})
         create_model('1 user', 'foo: "bar", baz: "bing bong"')
       end
 
@@ -142,7 +142,7 @@ describe Pickle::Session do
 
     describe "('an user: \"fred\")" do
       it "should call user_factory.create({})" do
-        user_factory.should_receive(:create).with({})
+        expect(user_factory).to receive(:create).with({})
         create_model('an user: "fred"')
       end
 
@@ -152,23 +152,23 @@ describe Pickle::Session do
         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
+          expect(created_model('the user: "fred"')).to eq(user)
         end
 
         it "created_model?('the user: \"shirl\"') should be false" do
-          created_model?('the user: "shirl"').should == false
+          expect(created_model?('the user: "shirl"')).to eq(false)
         end
 
         it "model?('the user: \"shirl\"') should be false" do
-          model?('the user: "shirl"').should == false
+          expect(model?('the user: "shirl"')).to eq(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'}).should == user
+        expect(user_factory).to receive(:create).with({'foo' => 'bar'})
+        expect(create_model('a user', {'foo' => 'bar'})).to eq(user)
       end
 
       describe "after create," do
@@ -181,11 +181,11 @@ describe Pickle::Session do
 
   describe '#find_model' do
     before do
-      Pickle::Adapter.stub!(:find_first_model).with(user_class, anything).and_return(user)
+      allow(Pickle::Adapter).to receive(:find_first_model).with(user_class, anything).and_return(user)
     end
 
     it "should call user_class.find :first, :conditions => {<fields>}" do
-      find_model('a user', 'hair: "pink"').should == user
+      expect(find_model('a user', 'hair: "pink"')).to eq(user)
     end
 
     describe "after find," do
@@ -210,60 +210,60 @@ describe Pickle::Session do
   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'}])
+        double(: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]
+        expect(self).to receive(:create_model).with("user", 'name' => "Fred").once.ordered.and_return(:fred)
+        expect(self).to receive(:create_model).with("user", 'name' => "Betty").once.ordered.and_return(:betty)
+        expect(create_models_from_table("users", table)).to eq([: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]
+        expect(self).to receive(:find_model).with("user", 'name' => "Fred").once.ordered.and_return(:fred)
+        expect(self).to receive(:find_model).with("user", 'name' => "Betty").once.ordered.and_return(:betty)
+        expect(find_models_from_table("users", table)).to eq([: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'}])
+        double(: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]
+        expect(self).to receive(:create_model).with("user \"fred\"", 'name' => "Fred").once.ordered.and_return(:fred)
+        expect(self).to receive(:create_model).with("user \"betty\"", 'name' => "Betty").once.ordered.and_return(:betty)
+        expect(create_models_from_table("users", table)).to eq([: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)
-        find_models_from_table("users", table).should == [:fred, :betty]
+        expect(self).to receive(:find_model).with("user \"fred\"", 'name' => "Fred").once.ordered.and_return(:fred)
+        expect(self).to receive(:find_model).with("user \"betty\"", 'name' => "Betty").once.ordered.and_return(:betty)
+        expect(find_models_from_table("users", table)).to eq([:fred, :betty])
       end
     end
   end
 
   describe "#find_model!" do
     it "should call find_model" do
-      should_receive(:find_model).with('name', 'fields').and_return(user)
+      expect(self).to receive(:find_model).with('name', 'fields').and_return(user)
       find_model!('name', 'fields')
     end
 
     it "should call raise error if find_model returns nil" do
-      should_receive(:find_model).with('name', 'fields').and_return(nil)
-      lambda { find_model!('name', 'fields') }.should raise_error(Pickle::Session::ModelNotFoundError)
+      expect(self).to receive(:find_model).with('name', 'fields').and_return(nil)
+      expect { find_model!('name', 'fields') }.to raise_error(Pickle::Session::ModelNotFoundError)
     end
   end
 
   describe "#find_models" do
     before do
-      Pickle::Adapter.stub!(:find_all_models).with(user_class, anything).and_return([user])
+      allow(Pickle::Adapter).to receive(:find_all_models).with(user_class, anything).and_return([user])
     end
 
     it "should call User.find :all, :conditions => {'hair' => 'pink'}" do
-      find_models('user', 'hair: "pink"').should == [user]
+      expect(find_models('user', 'hair: "pink"')).to eq([user])
     end
 
     describe "after find," do
@@ -273,27 +273,27 @@ describe Pickle::Session do
     end
     
     it "should cope with spaces in the factory name (ie. it should make it canonical)" do
-      pickle_parser.stub!(:canonical).and_return('user')
-      pickle_parser.should_receive(:canonical).with('u ser').and_return('user')
-      find_models('u ser', 'hair: "pink"').should == [user]
+      allow(pickle_parser).to receive(:canonical).and_return('user')
+      expect(pickle_parser).to receive(:canonical).with('u ser').and_return('user')
+      expect(find_models('u ser', 'hair: "pink"')).to eq([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, :id => 4) }
+    let(:fred) { double("fred", :class => user_class, :id => 2) }
+    let(:shirl) { double("shirl", :class => user_class, :id => 3) }
+    let(:noname) { double("noname", :class => user_class, :id => 4) }
     
     if defined? ::FactoryGirl
-      let(:super_admin_factory) { Pickle::Adapter::FactoryGirl.new(mock(:build_class => user_class, :name => :super_admin)) }
+      let(:super_admin_factory) { Pickle::Adapter::FactoryGirl.new(double(:build_class => user_class, :name => :super_admin)) }
     else
-      let(:super_admin_factory) { Pickle::Adapter::FactoryGirl.new(mock(:build_class => user_class, :factory_name => :super_admin)) }
+      let(:super_admin_factory) { Pickle::Adapter::FactoryGirl.new(double(: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)
+      allow(config).to receive(:factories).and_return(user_factory.name => user_factory, super_admin_factory.name => super_admin_factory)
+      allow(user_factory).to receive(:create).and_return(shirl)
+      allow(super_admin_factory).to receive(:create).and_return(fred, noname)
     end
 
     def do_create_users
@@ -303,8 +303,8 @@ describe Pickle::Session do
     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
+      expect(super_admin_factory).to receive(:create).with({}).twice
+      expect(user_factory).to receive(:create).with({}).once
       do_create_users
     end
 
@@ -314,44 +314,44 @@ describe Pickle::Session do
       end
 
       it "created_models('user') should == [fred, shirl, noname]" do
-        created_models('user').should == [fred, shirl, noname]
+        expect(created_models('user')).to eq([fred, shirl, noname])
       end
 
       it "created_models('super_admin') should == [fred, noname]" do
-        created_models('super_admin').should == [fred, noname]
+        expect(created_models('super_admin')).to eq([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
+          expect(created_model('that user')).to eq(noname)
         end
 
         it "'the super admin' should be noname (the last super admin created)" do
-          created_model('that super admin').should == noname
+          expect(created_model('that super admin')).to eq(noname)
         end
 
         it "'the 1st super admin' should be fred" do
-          created_model('the 1st super admin').should == fred
+          expect(created_model('the 1st super admin')).to eq(fred)
         end
 
         it "'the first user' should be fred" do
-          created_model('the first user').should == fred
+          expect(created_model('the first user')).to eq(fred)
         end
 
         it "'the 2nd user' should be shirl" do
-          created_model('the 2nd user').should == shirl
+          expect(created_model('the 2nd user')).to eq(shirl)
         end
 
         it "'the last user' should be noname" do
-          created_model('the last user').should == noname
+          expect(created_model('the last user')).to eq(noname)
         end
 
         it "'the user: \"fred\" should be fred" do
-          created_model('the user: "fred"').should == fred
+          expect(created_model('the user: "fred"')).to eq(fred)
         end
 
         it "'the user: \"shirl\" should be shirl" do
-          created_model('the user: "shirl"').should == shirl
+          expect(created_model('the user: "shirl"')).to eq(shirl)
         end
       end
     end
@@ -360,73 +360,73 @@ describe Pickle::Session do
   describe "when 'the user: \"me\"' exists and there is a mapping from 'I', 'myself' => 'user: \"me\"" 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)
-      Pickle::Adapter.stub!(:get_model).with(user_class, anything).and_return(user)
-      user_factory.stub!(:create).and_return(user)
+      allow(config).to receive(:factories).and_return('user' => user_factory)
+      allow(Pickle::Adapter).to receive(:get_model).with(user_class, anything).and_return(user)
+      allow(user_factory).to receive(:create).and_return(user)
       create_model('the user: "me"')
     end
 
     it 'model("I") should return the user' do
-      model('I').should == user
+      expect(model('I')).to eq(user)
     end
 
     it 'model("myself") should return the user' do
-      model('myself').should == user
+      expect(model('myself')).to eq(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
+      expect { pickle_parser.parse_fields('author: user "JIM"') }.to 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}
+      expect(pickle_parser.parse_fields('author: the user')).to eq({"author" => user})
     end
 
     it "#parser.parse_fields 'author: myself' should return {\"author\" => <user>}" do
-      pickle_parser.parse_fields('author: myself').should == {"author" => user}
+      expect(pickle_parser.parse_fields('author: myself')).to eq({"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'}
+      expect(pickle_parser.parse_fields('author: the user, approver: I, rating: "5"')).to eq({'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' => ""}
+      expect(pickle_parser.parse_fields('author: user: "me", approver: ""')).to eq({'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)
+      allow(user).to receive(: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'], :const_get => ActiveRecord::Base::PickleAdapter)
+        double('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}
+        expect(convert_models_to_attributes(ar_class, :user => user)).to eq({'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'], :const_get => ActiveRecord::Base::PickleAdapter)
+        double('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
-        user.class.should_receive(:base_class).and_return(mock('User base class', :name => 'UserBase'))
-        convert_models_to_attributes(ar_class, :user => user).should == {'user_id' => user.id, 'user_type' => 'UserBase'}
+        expect(user.class).to receive(:base_class).and_return(double('User base class', :name => 'UserBase'))
+        expect(convert_models_to_attributes(ar_class, :user => user)).to eq({'user_id' => user.id, 'user_type' => 'UserBase'})
       end
     end
   end
 
   it "#model!('unknown') should raise informative error message" do
-    lambda { model!('unknown') }.should raise_error(Pickle::Session::ModelNotKnownError, "The model: 'unknown' is not known in this scenario.  Use #create_model to create, or #find_model to find, and store a reference in this scenario.")
+    expect { model!('unknown') }.to raise_error(Pickle::Session::ModelNotKnownError, "The model: 'unknown' is not known in this scenario.  Use #create_model to create, or #find_model to find, and store a reference in this scenario.")
   end
 
   it "#created_model!('unknown') should raise informative error message" do
-    lambda { created_model!('unknown') }.should raise_error(Pickle::Session::ModelNotKnownError)
+    expect { created_model!('unknown') }.to raise_error(Pickle::Session::ModelNotKnownError)
   end
 end