pickle 0.4.11 → 0.5.0

data/spec/pickle/adapter_spec.rb

@@ -8,11 +8,11 @@ require 'pickle/adapters/active_record'
 
 describe Pickle::Adapter do
   it ".factories should raise NotImplementedError" do
-    lambda { Pickle::Adapter.factories }.should raise_error(NotImplementedError)
+    expect { Pickle::Adapter.factories }.to raise_error(NotImplementedError)
   end
 
   it "#create should raise NotImplementedError" do
-    lambda { Pickle::Adapter.new.create }.should raise_error(NotImplementedError)
+    expect { Pickle::Adapter.new.create }.to raise_error(NotImplementedError)
   end
 
   describe ".model_classes" do
@@ -23,9 +23,9 @@ describe Pickle::Adapter do
 
   describe "adapters: " do
     before do
-      @klass1 = Class.new(ActiveRecord::Base).tap { |k| k.stub!(:name).and_return('One') }
-      @klass2 = Class.new(ActiveRecord::Base).tap { |k| k.stub!(:name).and_return('One::Two') }
-      @klass3 = Class.new(ActiveRecord::Base).tap { |k| k.stub!(:name).and_return('Three') }
+      @klass1 = Class.new(ActiveRecord::Base).tap { |k| allow(k).to receive(:name).and_return('One') }
+      @klass2 = Class.new(ActiveRecord::Base).tap { |k| allow(k).to receive(:name).and_return('One::Two') }
+      @klass3 = Class.new(ActiveRecord::Base).tap { |k| allow(k).to receive(:name).and_return('Three') }
     end
 
     describe 'ActiveRecord' do
@@ -34,8 +34,8 @@ describe Pickle::Adapter do
 
       describe ".model_classes" do
         it "calls .descendants" do
-          ::ActiveRecord::Base.should_receive(:descendants).and_return([])
-          ::ActiveRecord::Base.should_not_receive(:subclasses).and_return([])
+          expect(::ActiveRecord::Base).to receive(:descendants).and_return([])
+          expect(::ActiveRecord::Base).not_to receive(:subclasses)
 
           ActiveRecord::Base::PickleAdapter.model_classes
         end
@@ -43,14 +43,14 @@ describe Pickle::Adapter do
 
       describe 'with class stubs' do
         before do
-          Pickle::Adapter::Orm.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+          allow(Pickle::Adapter::Orm).to receive(:model_classes).and_return([@klass1, @klass2, @klass3])
         end
 
         it ".factories should create one for each active record class" do
-          Pickle::Adapter::Orm.should_receive(:new).with(@klass1).once
-          Pickle::Adapter::Orm.should_receive(:new).with(@klass2).once
-          Pickle::Adapter::Orm.should_receive(:new).with(@klass3).once
-          Pickle::Adapter::Orm.factories.length.should == 3
+          expect(Pickle::Adapter::Orm).to receive(:new).with(@klass1).once
+          expect(Pickle::Adapter::Orm).to receive(:new).with(@klass2).once
+          expect(Pickle::Adapter::Orm).to receive(:new).with(@klass3).once
+          expect(Pickle::Adapter::Orm.factories.length).to eq(3)
         end
 
         describe ".new(Class)" do
@@ -59,11 +59,11 @@ describe Pickle::Adapter do
           end
 
           it "should have underscored (s/_) name of Class as #name" do
-            @factory.name.should == 'one_two'
+            expect(@factory.name).to eq('one_two')
           end
 
           it "#create(attrs) should call Class.create!(attrs)" do
-            @klass2.should_receive(:create!).with({:key => "val"})
+            expect(@klass2).to receive(:create!).with({:key => "val"})
             @factory.create(:key => "val")
           end
         end
@@ -72,7 +72,7 @@ describe Pickle::Adapter do
 
     describe 'FactoryGirl' do
       before do
-        Pickle::Adapter::FactoryGirl.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+        allow(Pickle::Adapter::FactoryGirl).to receive(:model_classes).and_return([@klass1, @klass2, @klass3])
 
         if defined? ::FactoryGirl
           @orig_factories = ::FactoryGirl.factories.dup
@@ -100,8 +100,8 @@ describe Pickle::Adapter do
       end
 
       it ".factories should create one for each factory" do
-        Pickle::Adapter::FactoryGirl.should_receive(:new).with(@factory1).once
-        Pickle::Adapter::FactoryGirl.should_receive(:new).with(@factory2).once
+        expect(Pickle::Adapter::FactoryGirl).to receive(:new).with(@factory1).once
+        expect(Pickle::Adapter::FactoryGirl).to receive(:new).with(@factory2).once
         Pickle::Adapter::FactoryGirl.factories
       end
 
@@ -111,16 +111,16 @@ describe Pickle::Adapter do
         end
 
         it "should have name of factory_name" do
-          @factory.name.should == 'one'
+          expect(@factory.name).to eq('one')
         end
 
         it "should have klass of build_class" do
-          @factory.klass.should == @klass1
+          expect(@factory.klass).to eq(@klass1)
         end
 
         unless defined? ::FactoryGirl
           it "#create(attrs) should call Factory(<:key>, attrs)" do
-            Factory.should_receive(:create).with("one", {:key => "val"})
+            expect(Factory).to receive(:create).with("one", {:key => "val"})
             @factory.create(:key => "val")
           end
         end
@@ -129,14 +129,14 @@ describe Pickle::Adapter do
 
     describe 'Fabrication' do
       before do
-        @schematic1 = [:one, Fabrication::Schematic.new(@klass1)]
-        @schematic2 = [:two, Fabrication::Schematic.new(@klass2)]
-        ::Fabrication::Fabricator.stub(:schematics).and_return([@schematic1, @schematic2])
+        @schematic1 = [:one, Fabrication::Schematic::Definition.new(@klass1)]
+        @schematic2 = [:two, Fabrication::Schematic::Definition.new(@klass2)]
+        allow(::Fabrication.manager).to receive(:schematics).and_return(Hash[[@schematic1, @schematic2]])
       end
 
       it '.factories should create one for each fabricator' do
-        Pickle::Adapter::Fabrication.should_receive(:new).with(@schematic1)
-        Pickle::Adapter::Fabrication.should_receive(:new).with(@schematic2)
+        expect(Pickle::Adapter::Fabrication).to receive(:new).with(@schematic1)
+        expect(Pickle::Adapter::Fabrication).to receive(:new).with(@schematic2)
 
         Pickle::Adapter::Fabrication.factories
       end
@@ -147,19 +147,19 @@ describe Pickle::Adapter do
         end
 
         it ".new should have name of schematic name" do
-          @factory.name.should == 'one'
+          expect(@factory.name).to eq('one')
         end
 
         it "should have klass of build_class" do
-          @factory.klass.should == @klass1
+          expect(@factory.klass).to eq(@klass1)
         end
       end
 
       describe ".create" do
         it "returns the fabricated instance" do
           @factory = Pickle::Adapter::Fabrication.new(@schematic1)
-          ::Fabrication::Fabricator.should_receive(:generate).
-              with(@factory.name.to_sym, {:save => true}, {:attribute => 'value'})
+          expect(Fabricate).to receive(:create).
+              with(@factory.name.to_sym, {:attribute => 'value'})
           @factory.create({:attribute => 'value'})
         end
       end
@@ -167,7 +167,7 @@ describe Pickle::Adapter do
 
     describe 'Machinist' do
       before do
-        Pickle::Adapter::Machinist.stub!(:model_classes).and_return([@klass1, @klass2, @klass3])
+        allow(Pickle::Adapter::Machinist).to receive(:model_classes).and_return([@klass1, @klass2, @klass3])
 
         @klass1.blueprint {}
         @klass3.blueprint {}
@@ -175,9 +175,9 @@ describe Pickle::Adapter do
       end
 
       it ".factories should create one for each master blueprint, and special case" do
-        Pickle::Adapter::Machinist.should_receive(:new).with(@klass1, :master).once
-        Pickle::Adapter::Machinist.should_receive(:new).with(@klass3, :master).once
-        Pickle::Adapter::Machinist.should_receive(:new).with(@klass3, :special).once
+        expect(Pickle::Adapter::Machinist).to receive(:new).with(@klass1, :master).once
+        expect(Pickle::Adapter::Machinist).to receive(:new).with(@klass3, :master).once
+        expect(Pickle::Adapter::Machinist).to receive(:new).with(@klass3, :special).once
         Pickle::Adapter::Machinist.factories
       end
 
@@ -187,11 +187,11 @@ describe Pickle::Adapter do
         end
 
         it "should have underscored (s/_) name of Class as #name" do
-          @factory.name.should == 'one'
+          expect(@factory.name).to eq('one')
         end
 
-        it "#create(attrs) should call Class.make(:master, attrs)" do
-          @klass1.should_receive(:make).with(:master, {:key => "val"})
+        it "#create(attrs) should call Class.make!(:master, attrs)" do
+          expect(@klass1).to receive(:make!).with(:master, {:key => "val"})
           @factory.create(:key => "val")
         end
       end
@@ -202,11 +202,11 @@ describe Pickle::Adapter do
         end
 
         it "should have 'special_<Class name>' as #name" do
-          @factory.name.should == 'special_three'
+          expect(@factory.name).to eq('special_three')
         end
 
-        it "#create(attrs) should call Class.make(:special, attrs)" do
-          @klass3.should_receive(:make).with(:special, {:key => "val"})
+        it "#create(attrs) should call Class.make!(:special, attrs)" do
+          expect(@klass3).to receive(:make!).with(:special, {:key => "val"})
           @factory.create(:key => "val")
         end
       end

data/spec/pickle/config_spec.rb

@@ -6,11 +6,11 @@ describe Pickle::Config do
   end
 
   it "#adapters should default to :machinist, :factory_girl, :orm" do
-    @config.adapters.should == [:machinist, :factory_girl, :fabrication, :orm]
+    expect(@config.adapters).to eq([:machinist, :factory_girl, :fabrication, :orm])
   end
 
   it "#adapter_classes should default to Adapter::Machinist, Adapter::FactoryGirl, Adapter::Orm" do
-    @config.adapter_classes.should == [Pickle::Adapter::Machinist, Pickle::Adapter::FactoryGirl, Pickle::Adapter::Fabrication, Pickle::Adapter::Orm]
+    expect(@config.adapter_classes).to eq([Pickle::Adapter::Machinist, Pickle::Adapter::FactoryGirl, Pickle::Adapter::Fabrication, Pickle::Adapter::Orm])
   end
 
   describe "setting adapters to [:machinist, SomeAdapter]" do
@@ -21,60 +21,60 @@ describe Pickle::Config do
     end
 
     it "#adapter_classes should be Adapter::Machinist, SomeAdapter" do
-      @config.adapter_classes.should == [Pickle::Adapter::Machinist, SomeAdapter]
+      expect(@config.adapter_classes).to eq([Pickle::Adapter::Machinist, SomeAdapter])
     end
   end
 
   describe "#factories" do
     it "should call adaptor.factories for each adaptor" do
-      Pickle::Adapter::Machinist.should_receive(:factories).and_return([])
-      Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([])
-      Pickle::Adapter::Fabrication.should_receive(:factories).and_return([])
-      Pickle::Adapter::Orm.should_receive(:factories).and_return([])
+      expect(Pickle::Adapter::Machinist).to receive(:factories).and_return([])
+      expect(Pickle::Adapter::FactoryGirl).to receive(:factories).and_return([])
+      expect(Pickle::Adapter::Fabrication).to receive(:factories).and_return([])
+      expect(Pickle::Adapter::Orm).to receive(:factories).and_return([])
       @config.factories
     end
 
     it "should aggregate factories into a hash using factory name as key" do
-      Pickle::Adapter::Machinist.should_receive(:factories).and_return([@machinist = mock('machinist', :name => 'machinist')])
-      Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([@factory_girl = mock('factory_girl', :name => 'factory_girl')])
-      Pickle::Adapter::Fabrication.should_receive(:factories).and_return([@fabrication = mock('fabrication', :name => 'fabrication')])
-      Pickle::Adapter::Orm.should_receive(:factories).and_return([@orm = mock('orm', :name => 'orm')])
-      @config.factories.should == {'machinist' => @machinist, 'factory_girl' => @factory_girl, 'fabrication' => @fabrication, 'orm' => @orm}
+      expect(Pickle::Adapter::Machinist).to receive(:factories).and_return([@machinist = double('machinist', :name => 'machinist')])
+      expect(Pickle::Adapter::FactoryGirl).to receive(:factories).and_return([@factory_girl = double('factory_girl', :name => 'factory_girl')])
+      expect(Pickle::Adapter::Fabrication).to receive(:factories).and_return([@fabrication = double('fabrication', :name => 'fabrication')])
+      expect(Pickle::Adapter::Orm).to receive(:factories).and_return([@orm = double('orm', :name => 'orm')])
+      expect(@config.factories).to eq({'machinist' => @machinist, 'factory_girl' => @factory_girl, 'fabrication' => @fabrication, 'orm' => @orm})
     end
 
     it "should give preference to adaptors first in the list" do
-      Pickle::Adapter::Machinist.should_receive(:factories).and_return([@machinist_one = mock('one', :name => 'one')])
-      Pickle::Adapter::FactoryGirl.should_receive(:factories).and_return([@factory_girl_one = mock('one', :name => 'one'), @factory_girl_two = mock('two', :name => 'two')])
-      Pickle::Adapter::Fabrication.should_receive(:factories).and_return([@fabrication_one = mock('one', :name => 'one'), @fabrication_three = mock('three', :name => 'three')])
-      Pickle::Adapter::Orm.should_receive(:factories).and_return([@orm_two = mock('two', :name => 'two'), @orm_four = mock('four', :name => 'four')])
-      @config.factories.should == {'one' => @machinist_one, 'two' => @factory_girl_two, 'three' => @fabrication_three, 'four' => @orm_four}
+      expect(Pickle::Adapter::Machinist).to receive(:factories).and_return([@machinist_one = double('one', :name => 'one')])
+      expect(Pickle::Adapter::FactoryGirl).to receive(:factories).and_return([@factory_girl_one = double('one', :name => 'one'), @factory_girl_two = double('two', :name => 'two')])
+      expect(Pickle::Adapter::Fabrication).to receive(:factories).and_return([@fabrication_one = double('one', :name => 'one'), @fabrication_three = double('three', :name => 'three')])
+      expect(Pickle::Adapter::Orm).to receive(:factories).and_return([@orm_two = double('two', :name => 'two'), @orm_four = double('four', :name => 'four')])
+      expect(@config.factories).to eq({'one' => @machinist_one, 'two' => @factory_girl_two, 'three' => @fabrication_three, 'four' => @orm_four})
     end
   end
 
   it "#mappings should default to []" do
-    @config.mappings.should == []
+    expect(@config.mappings).to eq([])
   end
 
   describe '#predicates' do
     it "should be list of all non object ? public instance methods + columns methods of Adapter.model_classes" do
-      class1 = mock('Class1',
+      class1 = double('Class1',
                     :public_instance_methods => ['nope', 'foo?', 'bar?'],
                     :column_names => ['one', 'two'],
                     :const_get => ::ActiveRecord::Base::PickleAdapter
       )
-      class2 = mock('Class2',
+      class2 = double('Class2',
                     :public_instance_methods => ['not', 'foo?', 'faz?'],
                     :column_names => ['two', 'three'],
                     :const_get => ::ActiveRecord::Base::PickleAdapter
       )
-      Pickle::Adapter.stub!(:model_classes).and_return([class1, class2])
+      allow(Pickle::Adapter).to receive(:model_classes).and_return([class1, class2])
 
-      @config.predicates.to_set.should == ['foo?', 'faz?', 'bar?', 'one', 'two', 'three'].to_set
+      expect(@config.predicates.to_set).to eq(['foo?', 'faz?', 'bar?', 'one', 'two', 'three'].to_set)
     end
 
     it "should be overridable" do
       @config.predicates = %w(lame?)
-      @config.predicates.should == %w(lame?)
+      expect(@config.predicates).to eq(%w(lame?))
     end
   end
 
@@ -85,9 +85,9 @@ describe Pickle::Config do
 
     it "should create Mapping('foo', 'faz') mapping" do
       @config.mappings.first.tap do |mapping|
-        mapping.should be_kind_of Pickle::Config::Mapping
-        mapping.search.should == 'foo'
-        mapping.replacement.should == 'faz'
+        expect(mapping).to be_kind_of Pickle::Config::Mapping
+        expect(mapping.search).to eq('foo')
+        expect(mapping.replacement).to eq('faz')
       end
     end
   end
@@ -98,13 +98,13 @@ describe Pickle::Config do
     end
 
     it "should create 2 mappings" do
-      @config.mappings.first.should == Pickle::Config::Mapping.new('foo', 'faz')
-      @config.mappings.last.should == Pickle::Config::Mapping.new('bar', 'faz')
+      expect(@config.mappings.first).to eq(Pickle::Config::Mapping.new('foo', 'faz'))
+      expect(@config.mappings.last).to eq(Pickle::Config::Mapping.new('bar', 'faz'))
     end
   end
 
   it "#configure(&block) should execiute on self" do
-    @config.should_receive(:foo).with(:bar)
+    expect(@config).to receive(:foo).with(:bar)
     @config.configure do |c|
       c.foo :bar
     end

data/spec/pickle/email/parser_spec.rb

@@ -8,44 +8,44 @@ describe Pickle::Email::Parser do
   
   describe "#match_email" do
     it "should match 'the email'" do
-      'the email'.should match(/^#{match_email}$/)
+      expect('the email').to match(/^#{match_email}$/)
     end
     
     it "should match 'the first email'" do
-      'the first email'.should match(/^#{match_email}$/)
+      expect('the first email').to match(/^#{match_email}$/)
     end
     
     it "should match 'the last email'" do
-      'the last email'.should match(/^#{match_email}$/)
+      expect('the last email').to match(/^#{match_email}$/)
     end
     
     it "should match 'the 3rd email'" do
-      'the 3rd email'.should match(/^#{match_email}$/)
+      expect('the 3rd email').to match(/^#{match_email}$/)
     end
     
     it "should match 'an email'" do
-      'an email'.should match(/^#{match_email}$/)
+      expect('an email').to match(/^#{match_email}$/)
     end
   end
   
   it "#capture_email should just capture match_email" do
-    capture_email.should == "(#{match_email})"
+    expect(capture_email).to eq("(#{match_email})")
   end
   
   describe "#capture_index_in_email" do
     it "should extract the '2nd' from 'the 2nd email'" do
       match = 'the 2nd email'.match(/^#{capture_index_in_email}$/)
-      match[1].should == '2nd'
+      expect(match[1]).to eq('2nd')
     end
     
     it "should extract nil from 'the email'" do
       match = 'the email'.match(/^#{capture_index_in_email}$/)
-      match[1].should == nil
+      expect(match[1]).to eq(nil)
     end
     
     it "should extract the 'last' from 'the last email'" do
       match = 'the last email'.match(/^#{capture_index_in_email}$/)
-      match[1].should == 'last'
+      expect(match[1]).to eq('last')
     end
   end
 end

data/spec/pickle/email_spec.rb

@@ -10,17 +10,17 @@ describe Pickle::Email do
   include Pickle::Email::Parser
 
   before do
-    @email1 = mock("Email 1")
-    @email2 = mock("Email 2")
-    ActionMailer::Base.stub!(:deliveries).and_return([@email1, @email2])
+    @email1 = double("Email 1")
+    @email2 = double("Email 2")
+    allow(ActionMailer::Base).to receive(:deliveries).and_return([@email1, @email2])
     if defined?(ActiveRecord::Base)
-      ActiveRecord::Base::PickleAdapter.stub!(:model_classes).and_return([])
+      allow(ActiveRecord::Base::PickleAdapter).to receive(:model_classes).and_return([])
     end
   end
 
   describe "#emails" do
     it "should return ordered deliveries" do
-      emails.should == [@email1, @email2]
+      expect(emails).to eq([@email1, @email2])
     end
 
     describe "(after)" do
@@ -29,38 +29,38 @@ describe Pickle::Email do
       end
 
       it "#email('the email') should return the last delivery" do
-        email('the email').should == @email2
+        expect(email('the email')).to eq(@email2)
       end
 
       it "#email('the 1st email') should return the first delivery" do
-        email('the 1st email').should == @email1
+        expect(email('the 1st email')).to eq(@email1)
       end
 
       it "#email('the first email') should return the first delivery" do
-        email('the first email').should == @email1
+        expect(email('the first email')).to eq(@email1)
       end
 
       it "#email('the 2nd email') should return the second delivery" do
-        email('the 2nd email').should == @email2
+        expect(email('the 2nd email')).to eq(@email2)
       end
 
       it "#email('the last email') should return the second delivery" do
-        email('the last email').should == @email2
+        expect(email('the last email')).to eq(@email2)
       end
 
       it "#email2('the 3rd email') should be nil" do
-        email('the 3rd email').should == nil
+        expect(email('the 3rd email')).to eq(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')
+        allow(@email1).to receive(:to).and_return(['fred@gmail.com', 'joe@gmail.com'])
+        allow(@email2).to receive(: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]
+        expect(emails('to: "fred@gmail.com"')).to eq([@email1])
       end
 
       describe "after #emails('to: \"fred@gmail.com\"')" do
@@ -69,35 +69,35 @@ describe Pickle::Email do
         end
 
         it "#email('first') should be #email('last')" do
-          email('first email').should == email('last email')
-          email('first email').should == @email1
+          expect(email('first email')).to eq(email('last email'))
+          expect(email('first email')).to eq(@email1)
         end
 
         it "#email('the email', 'to: \"blah\") should be nil" do
-          email('the email', 'to: "blah"').should == nil
+          expect(email('the email', 'to: "blah"')).to eq(nil)
         end
 
         it "#email('the email', 'to: \"fred@gmail.com\") should be email1" do
-          email('the email', 'to: "fred@gmail.com"').should == @email1
+          expect(email('the email', 'to: "fred@gmail.com"')).to eq(@email1)
         end
       end
 
       it "#emails('to: \"joe@gmail.com\"') should return both emails" do
-        emails('to: "joe@gmail.com"').should == [@email1, @email2]
+        expect(emails('to: "joe@gmail.com"')).to eq([@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')
+          allow(@email1).to receive(:subject).and_return('email1')
+          allow(@email2).to receive(: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]
+          expect(emails('to: "joe@gmail.com", subject: "email1"')).to eq([@email1])
         end
 
         it "#emails('to: \"fred@gmail.com\", subject: \"email2\"') should return empty array" do
-          emails('to: "fred@gmail.com", subject: "email2"').should == []
+          expect(emails('to: "fred@gmail.com", subject: "email2"')).to eq([])
         end
       end
     end
@@ -105,14 +105,14 @@ describe Pickle::Email do
 
   describe "#save_and_open_emails" do
     before do
-      stub!(:open_in_browser)
-      stub!(:emails).and_return(["Contents of Email 1"])
+      allow(self).to receive(:open_in_browser)
+      allow(self).to receive(:emails).and_return(["Contents of Email 1"])
       @now = "2008-01-01".to_time
-      Time.stub!(:now).and_return(@now)
+      allow(Time).to receive(:now).and_return(@now)
     end
 
     it "should call #emails to get emails" do
-      should_receive(:emails).and_return([])
+      expect(self).to receive(:emails).and_return([])
       save_and_open_emails
     end
 
@@ -120,47 +120,47 @@ describe Pickle::Email do
       before { @emails = [] }
 
       it "should not call #emails" do
-        should_not_receive(:emails)
+        expect(self).not_to 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 />"
+      expect(File.read("pickle-email-#{@now.to_i}.html")).to eq("<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("pickle-email-#{@now.to_i}.html")
+      expect(self).to receive(:open_in_browser).with("pickle-email-#{@now.to_i}.html")
       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')
+      allow(self).to receive(:open_in_browser)
+      allow(@email1).to receive(: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('http://example.com/page')
+      expect(self).to receive(:visit).with('http://example.com/page')
       visit_in_email(@email1, 'http://example.com/page')
     end
 
     it "should find a link for \"example page\"" do
-      should_receive(:visit).with('http://example.com/page')
+      expect(self).to receive(:visit).with('http://example.com/page')
       visit_in_email(@email1, 'example page')
     end
 
     it "should follow the first link in an email" do
-      should_receive(:visit).with('http://example.com/page')
+      expect(self).to receive(:visit).with('http://example.com/page')
       click_first_link_in_email(@email1)
     end
     
     it "should not raise an error when the email body is not a string, but needs to_s [#26]" do
-      stub!(:visit)
-      @email1.stub!(:body).and_return(:a_string_body)
-      lambda { click_first_link_in_email(@email1) }.should_not raise_error
+      allow(self).to receive(:visit)
+      allow(@email1).to receive(:body).and_return(:a_string_body)
+      expect { click_first_link_in_email(@email1) }.not_to raise_error
     end
   end
 end