mailboxer 0.12.4 → 0.12.5

data/spec/models/mailboxer_models_messageable_spec.rb

@@ -12,15 +12,15 @@ describe "Mailboxer::Models::Messageable through User" do
   end
 
   it 'should return the inbox count' do
-    @entity1.unread_inbox_count.should == 0
+    expect(@entity1.unread_inbox_count).to eq 0
     @entity2.send_message(@entity1,"Body","Subject")
     @entity2.send_message(@entity1,"Body","Subject")
-    @entity1.unread_inbox_count.should == 2
+    expect(@entity1.unread_inbox_count).to eq 2
     @entity1.receipts.first.mark_as_read
-    @entity1.unread_inbox_count.should == 1
+    expect(@entity1.unread_inbox_count).to eq 1
     @entity2.send_message(@entity1,"Body","Subject")
     @entity2.send_message(@entity1,"Body","Subject")
-    @entity1.unread_inbox_count.should == 3
+    expect(@entity1.unread_inbox_count).to eq 3
   end
 
   it "should be able to send a message" do
@@ -39,62 +39,62 @@ describe "Mailboxer::Models::Messageable through User" do
 
   it "should be able to unread an owned Mailboxer::Receipt (mark as unread)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
     @entity1.mark_as_unread(@receipt)
-    @receipt.is_read.should==false
+    expect(@receipt.is_read).to eq false
   end
 
   it "should be able to read an owned Mailboxer::Receipt (mark as read)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
     @entity1.mark_as_unread(@receipt)
     @entity1.mark_as_read(@receipt)
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
   end
 
   it "should not be able to unread a not owned Mailboxer::Receipt (mark as unread)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
     @entity2.mark_as_unread(@receipt) #Should not change
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
   end
 
   it "should not be able to read a not owned Mailboxer::Receipt (mark as read)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
     @entity1.mark_as_unread(@receipt) #From read to unread
     @entity2.mark_as_read(@receipt) #Should not change
-    @receipt.is_read.should==false
+    expect(@receipt.is_read).to eq false
   end
 
   it "should be able to trash an owned Mailboxer::Receipt" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity1.trash(@receipt)
-    @receipt.trashed.should==true
+    expect(@receipt.trashed).to eq true
   end
 
   it "should be able to untrash an owned Mailboxer::Receipt" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity1.trash(@receipt)
     @entity1.untrash(@receipt)
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
   end
 
   it "should not be able to trash a not owned Mailboxer::Receipt" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity2.trash(@receipt) #Should not change
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
   end
 
   it "should not be able to untrash a not owned Mailboxer::Receipt" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity1.trash(@receipt) #From read to unread
     @entity2.untrash(@receipt) #Should not change
-    @receipt.trashed.should==true
+    expect(@receipt.trashed).to eq true
   end
 
 
@@ -102,69 +102,69 @@ describe "Mailboxer::Models::Messageable through User" do
   it "should be able to unread an owned Message (mark as unread)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @message = @receipt.message
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
     @entity1.mark_as_unread(@message)
-    @message.receipt_for(@entity1).first.is_read.should==false
+    expect(@message.receipt_for(@entity1).first.is_read).to eq false
   end
 
   it "should be able to read an owned Message (mark as read)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @message = @receipt.message
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
     @entity1.mark_as_unread(@message)
     @entity1.mark_as_read(@message)
-    @message.receipt_for(@entity1).first.is_read.should==true
+    expect(@message.receipt_for(@entity1).first.is_read).to eq true
   end
 
   it "should not be able to unread a not owned Message (mark as unread)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @message = @receipt.message
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
     @entity2.mark_as_unread(@message) #Should not change
-    @message.receipt_for(@entity1).first.is_read.should==true
+    expect(@message.receipt_for(@entity1).first.is_read).to eq true
   end
 
   it "should not be able to read a not owned Message (mark as read)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @message = @receipt.message
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
     @entity1.mark_as_unread(@message) #From read to unread
     @entity2.mark_as_read(@message) #Should not change
-    @message.receipt_for(@entity1).first.is_read.should==false
+    expect(@message.receipt_for(@entity1).first.is_read).to eq false
   end
 
   it "should be able to trash an owned Message" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @message = @receipt.message
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity1.trash(@message)
-    @message.receipt_for(@entity1).first.trashed.should==true
+    expect(@message.receipt_for(@entity1).first.trashed).to eq true
   end
 
   it "should be able to untrash an owned Message" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @message = @receipt.message
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity1.trash(@message)
     @entity1.untrash(@message)
-    @message.receipt_for(@entity1).first.trashed.should==false
+    expect(@message.receipt_for(@entity1).first.trashed).to eq false
   end
 
   it "should not be able to trash a not owned Message" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @message = @receipt.message
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity2.trash(@message) #Should not change
-    @message.receipt_for(@entity1).first.trashed.should==false
+    expect(@message.receipt_for(@entity1).first.trashed).to eq false
   end
 
   it "should not be able to untrash a not owned Message" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @message = @receipt.message
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity1.trash(@message) #From read to unread
     @entity2.untrash(@message) #Should not change
-    @message.receipt_for(@entity1).first.trashed.should==true
+    expect(@message.receipt_for(@entity1).first.trashed).to eq true
   end
 
 
@@ -172,69 +172,69 @@ describe "Mailboxer::Models::Messageable through User" do
   it "should be able to unread an owned Notification (mark as unread)" do
     @receipt = @entity1.notify("Subject","Body")
     @notification = @receipt.notification
-    @receipt.is_read.should==false
+    expect(@receipt.is_read).to eq false
     @entity1.mark_as_read(@notification)
     @entity1.mark_as_unread(@notification)
-    @notification.receipt_for(@entity1).first.is_read.should==false
+    expect(@notification.receipt_for(@entity1).first.is_read).to eq false
   end
 
   it "should be able to read an owned Notification (mark as read)" do
     @receipt = @entity1.notify("Subject","Body")
     @notification = @receipt.notification
-    @receipt.is_read.should==false
+    expect(@receipt.is_read).to eq false
     @entity1.mark_as_read(@notification)
-    @notification.receipt_for(@entity1).first.is_read.should==true
+    expect(@notification.receipt_for(@entity1).first.is_read).to eq true
   end
 
   it "should not be able to unread a not owned Notification (mark as unread)" do
     @receipt = @entity1.notify("Subject","Body")
     @notification = @receipt.notification
-    @receipt.is_read.should==false
+    expect(@receipt.is_read).to eq false
     @entity1.mark_as_read(@notification)
     @entity2.mark_as_unread(@notification)
-    @notification.receipt_for(@entity1).first.is_read.should==true
+    expect(@notification.receipt_for(@entity1).first.is_read).to eq true
   end
 
   it "should not be able to read a not owned Notification (mark as read)" do
     @receipt = @entity1.notify("Subject","Body")
     @notification = @receipt.notification
-    @receipt.is_read.should==false
+    expect(@receipt.is_read).to eq false
     @entity2.mark_as_read(@notification)
-    @notification.receipt_for(@entity1).first.is_read.should==false
+    expect(@notification.receipt_for(@entity1).first.is_read).to eq false
   end
 
   it "should be able to trash an owned Notification" do
     @receipt = @entity1.notify("Subject","Body")
     @notification = @receipt.notification
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity1.trash(@notification)
-    @notification.receipt_for(@entity1).first.trashed.should==true
+    expect(@notification.receipt_for(@entity1).first.trashed).to eq true
   end
 
   it "should be able to untrash an owned Notification" do
     @receipt = @entity1.notify("Subject","Body")
     @notification = @receipt.notification
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity1.trash(@notification)
     @entity1.untrash(@notification)
-    @notification.receipt_for(@entity1).first.trashed.should==false
+    expect(@notification.receipt_for(@entity1).first.trashed).to eq false
   end
 
   it "should not be able to trash a not owned Notification" do
     @receipt = @entity1.notify("Subject","Body")
     @notification = @receipt.notification
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity2.trash(@notification)
-    @notification.receipt_for(@entity1).first.trashed.should==false
+    expect(@notification.receipt_for(@entity1).first.trashed).to eq false
   end
 
   it "should not be able to untrash a not owned Notification" do
     @receipt = @entity1.notify("Subject","Body")
     @notification = @receipt.notification
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity1.trash(@notification)
     @entity2.untrash(@notification)
-    @notification.receipt_for(@entity1).first.trashed.should==true
+    expect(@notification.receipt_for(@entity1).first.trashed).to eq true
   end
 
 
@@ -242,75 +242,75 @@ describe "Mailboxer::Models::Messageable through User" do
   it "should be able to unread an owned Conversation (mark as unread)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @conversation = @receipt.conversation
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
     @entity1.mark_as_unread(@conversation)
-    @conversation.receipts_for(@entity1).first.is_read.should==false
+    expect(@conversation.receipts_for(@entity1).first.is_read).to eq false
   end
 
   it "should be able to read an owned Conversation (mark as read)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @conversation = @receipt.conversation
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
     @entity1.mark_as_unread(@conversation)
     @entity1.mark_as_read(@conversation)
-    @conversation.receipts_for(@entity1).first.is_read.should==true
+    expect(@conversation.receipts_for(@entity1).first.is_read).to eq true
   end
 
   it "should not be able to unread a not owned Conversation (mark as unread)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @conversation = @receipt.conversation
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
     @entity2.mark_as_unread(@conversation)
-    @conversation.receipts_for(@entity1).first.is_read.should==true
+    expect(@conversation.receipts_for(@entity1).first.is_read).to eq true
   end
 
   it "should not be able to read a not owned Conversation (mark as read)" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @conversation = @receipt.conversation
-    @receipt.is_read.should==true
+    expect(@receipt.is_read).to eq true
     @entity1.mark_as_unread(@conversation)
     @entity2.mark_as_read(@conversation)
-    @conversation.receipts_for(@entity1).first.is_read.should==false
+    expect(@conversation.receipts_for(@entity1).first.is_read).to eq false
   end
 
   it "should be able to trash an owned Conversation" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @conversation = @receipt.conversation
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity1.trash(@conversation)
-    @conversation.receipts_for(@entity1).first.trashed.should==true
+    expect(@conversation.receipts_for(@entity1).first.trashed).to eq true
   end
 
   it "should be able to untrash an owned Conversation" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @conversation = @receipt.conversation
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity1.trash(@conversation)
     @entity1.untrash(@conversation)
-    @conversation.receipts_for(@entity1).first.trashed.should==false
+    expect(@conversation.receipts_for(@entity1).first.trashed).to eq false
   end
 
   it "should not be able to trash a not owned Conversation" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @conversation = @receipt.conversation
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity2.trash(@conversation)
-    @conversation.receipts_for(@entity1).first.trashed.should==false
+    expect(@conversation.receipts_for(@entity1).first.trashed).to eq false
   end
 
   it "should not be able to untrash a not owned Conversation" do
     @receipt = @entity1.send_message(@entity2,"Body","Subject")
     @conversation = @receipt.conversation
-    @receipt.trashed.should==false
+    expect(@receipt.trashed).to eq false
     @entity1.trash(@conversation)
     @entity2.untrash(@conversation)
-    @conversation.receipts_for(@entity1).first.trashed.should==true
+    expect(@conversation.receipts_for(@entity1).first.trashed).to eq true
   end
 
   it "should be able to read attachment" do
     @receipt = @entity1.send_message(@entity2, "Body", "Subject", nil, File.open('spec/testfile.txt'))
     @conversation = @receipt.conversation
-    @conversation.messages.first.attachment_identifier.should=='testfile.txt'
+    expect(@conversation.messages.first.attachment_identifier).to eq 'testfile.txt'
   end
 
   it "should be the same message time as passed" do
@@ -319,10 +319,10 @@ describe "Mailboxer::Models::Messageable through User" do
     # We're going to compare the string representation, because ActiveSupport::TimeWithZone
     # has microsecond precision in ruby, but some databases don't support this level of precision.
     expected = message_time.utc.to_s
-    receipt.message.created_at.utc.to_s.should == expected
-    receipt.message.updated_at.utc.to_s.should == expected
-    receipt.message.conversation.created_at.utc.to_s.should == expected
-    receipt.message.conversation.updated_at.utc.to_s.should == expected
+    expect(receipt.message.created_at.utc.to_s).to eq expected
+    expect(receipt.message.updated_at.utc.to_s).to eq expected
+    expect(receipt.message.conversation.created_at.utc.to_s).to eq expected
+    expect(receipt.message.conversation.updated_at.utc.to_s).to eq expected
   end
 
 end

data/spec/models/message_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Mailboxer::Message do
-  
+
   before do
     @entity1 = FactoryGirl.create(:user)
     @entity2 = FactoryGirl.create(:user)
@@ -12,19 +12,19 @@ describe Mailboxer::Message do
     @message1 = @receipt1.notification
     @message4 = @receipt4.notification
     @conversation = @message1.conversation
-  end  
-  
+  end
+
   it "should have right recipients" do
-  	@receipt1.notification.recipients.count.should==2
-  	@receipt2.notification.recipients.count.should==2
-  	@receipt3.notification.recipients.count.should==2
-  	@receipt4.notification.recipients.count.should==2      
+  	expect(@receipt1.notification.recipients.count).to eq 2
+  	expect(@receipt2.notification.recipients.count).to eq 2
+  	expect(@receipt3.notification.recipients.count).to eq 2
+  	expect(@receipt4.notification.recipients.count).to eq 2
   end
 
   it "should be able to be marked as deleted" do
-    @receipt1.deleted.should==false
+    expect(@receipt1.deleted).to be false
     @message1.mark_as_deleted @entity1
-    @message1.is_deleted?(@entity1).should==true
+    expect(@message1.is_deleted?(@entity1)).to be true
   end
-    
+
 end

data/spec/models/notification_spec.rb

@@ -18,67 +18,67 @@ describe Mailboxer::Notification do
     @entity1.notify("Subject", "Body")
 
     #Check getting ALL receipts
-    @entity1.mailbox.receipts.size.should==1
+    expect(@entity1.mailbox.receipts.size).to eq 1
     receipt      = @entity1.mailbox.receipts.first
     notification = receipt.notification
-    notification.subject.should=="Subject"
-    notification.body.should=="Body"
+    expect(notification.subject).to eq "Subject"
+    expect(notification.body).to eq "Body"
 
     #Check getting NOTIFICATION receipts only
-    @entity1.mailbox.notifications.size.should==1
+    expect(@entity1.mailbox.notifications.size).to eq 1
     notification = @entity1.mailbox.notifications.first
-    notification.subject.should=="Subject"
-    notification.body.should=="Body"
+    expect(notification.subject).to eq "Subject"
+    expect(notification.body).to eq "Body"
   end
 
   it "should be unread by default" do
     @entity1.notify("Subject", "Body")
-    @entity1.mailbox.receipts.size.should==1
+    expect(@entity1.mailbox.receipts.size).to eq 1
     notification = @entity1.mailbox.receipts.first.notification
-    notification.should be_is_unread(@entity1)
+    expect(notification).to be_is_unread(@entity1)
   end
 
   it "should be able to marked as read" do
     @entity1.notify("Subject", "Body")
-    @entity1.mailbox.receipts.size.should==1
+    expect(@entity1.mailbox.receipts.size).to eq 1
     notification = @entity1.mailbox.receipts.first.notification
     notification.mark_as_read(@entity1)
-    notification.should be_is_read(@entity1)
+    expect(notification).to be_is_read(@entity1)
   end
 
   it "should notify several users" do
     recipients = [@entity1,@entity2,@entity3]
     Mailboxer::Notification.notify_all(recipients,"Subject","Body")
     #Check getting ALL receipts
-    @entity1.mailbox.receipts.size.should==1
+    expect(@entity1.mailbox.receipts.size).to eq 1
     receipt      = @entity1.mailbox.receipts.first
     notification = receipt.notification
-    notification.subject.should=="Subject"
-    notification.body.should=="Body"
-    @entity2.mailbox.receipts.size.should==1
+    expect(notification.subject).to eq "Subject"
+    expect(notification.body).to eq "Body"
+    expect(@entity2.mailbox.receipts.size).to eq 1
     receipt      = @entity2.mailbox.receipts.first
     notification = receipt.notification
-    notification.subject.should=="Subject"
-    notification.body.should=="Body"
-    @entity3.mailbox.receipts.size.should==1
+    expect(notification.subject).to eq "Subject"
+    expect(notification.body).to eq "Body"
+    expect(@entity3.mailbox.receipts.size).to eq 1
     receipt      = @entity3.mailbox.receipts.first
     notification = receipt.notification
-    notification.subject.should=="Subject"
-    notification.body.should=="Body"
+    expect(notification.subject).to eq "Subject"
+    expect(notification.body).to eq "Body"
 
     #Check getting NOTIFICATION receipts only
-    @entity1.mailbox.notifications.size.should==1
+    expect(@entity1.mailbox.notifications.size).to eq 1
     notification = @entity1.mailbox.notifications.first
-    notification.subject.should=="Subject"
-    notification.body.should=="Body"
-    @entity2.mailbox.notifications.size.should==1
+    expect(notification.subject).to eq "Subject"
+    expect(notification.body).to eq "Body"
+    expect(@entity2.mailbox.notifications.size).to eq 1
     notification = @entity2.mailbox.notifications.first
-    notification.subject.should=="Subject"
-    notification.body.should=="Body"
-    @entity3.mailbox.notifications.size.should==1
+    expect(notification.subject).to eq "Subject"
+    expect(notification.body).to eq "Body"
+    expect(@entity3.mailbox.notifications.size).to eq 1
     notification = @entity3.mailbox.notifications.first
-    notification.subject.should=="Subject"
-    notification.body.should=="Body"
+    expect(notification.subject).to eq "Subject"
+    expect(notification.body).to eq "Body"
 
   end
 
@@ -86,17 +86,17 @@ describe Mailboxer::Notification do
     Mailboxer::Notification.notify_all(@entity1,"Subject","Body")
 
     #Check getting ALL receipts
-    @entity1.mailbox.receipts.size.should==1
+    expect(@entity1.mailbox.receipts.size).to eq 1
     receipt      = @entity1.mailbox.receipts.first
     notification = receipt.notification
-    notification.subject.should=="Subject"
-    notification.body.should=="Body"
+    expect(notification.subject).to eq "Subject"
+    expect(notification.body).to eq "Body"
 
     #Check getting NOTIFICATION receipts only
-    @entity1.mailbox.notifications.size.should==1
+    expect(@entity1.mailbox.notifications.size).to eq 1
     notification = @entity1.mailbox.notifications.first
-    notification.subject.should=="Subject"
-    notification.body.should=="Body"
+    expect(notification.subject).to eq "Subject"
+    expect(notification.body).to eq "Body"
   end
 
   describe "scopes" do
@@ -107,21 +107,21 @@ describe Mailboxer::Notification do
       it "finds unread notifications" do
         unread_notification = scope_user.notify("Body", "Subject").notification
         notification.mark_as_read(scope_user)
-        Mailboxer::Notification.unread.last.should == unread_notification
+        expect(Mailboxer::Notification.unread.last).to eq unread_notification
       end
     end
 
     describe ".expired" do
       it "finds expired notifications" do
         notification.update_attributes(expires: 1.day.ago)
-        scope_user.mailbox.notifications.expired.count.should eq(1)
+        expect(scope_user.mailbox.notifications.expired.count).to eq(1)
       end
     end
 
     describe ".unexpired" do
       it "finds unexpired notifications" do
         notification.update_attributes(expires: 1.day.from_now)
-        scope_user.mailbox.notifications.unexpired.count.should eq(1)
+        expect(scope_user.mailbox.notifications.unexpired.count).to eq(1)
       end
     end
   end
@@ -131,11 +131,11 @@ describe Mailboxer::Notification do
 
     describe "when the notification is already expired" do
       before do
-        subject.stub(:expired? => true)
+        allow(subject).to receive(:expired?).and_return(true)
       end
       it 'should not update the expires attribute' do
-        subject.should_not_receive :expires=
-        subject.should_not_receive :save
+        expect(subject).not_to receive :expires=
+        expect(subject).not_to receive :save
         subject.expire
       end
     end
@@ -144,15 +144,15 @@ describe Mailboxer::Notification do
       let(:now) { Time.now }
       let(:one_second_ago) { now - 1.second }
       before do
-        Time.stub(:now => now)
-        subject.stub(:expired? => false)
+        allow(Time).to receive(:now).and_return(now)
+        allow(subject).to receive(:expired?).and_return(false)
       end
       it 'should update the expires attribute' do
-        subject.should_receive(:expires=).with(one_second_ago)
+        expect(subject).to receive(:expires=).with(one_second_ago)
         subject.expire
       end
       it 'should not save the record' do
-        subject.should_not_receive :save
+        expect(subject).not_to receive :save
         subject.expire
       end
     end
@@ -164,11 +164,11 @@ describe Mailboxer::Notification do
 
     describe "when the notification is already expired" do
       before do
-        subject.stub(:expired? => true)
+        allow(subject).to receive(:expired?).and_return(true)
       end
       it 'should not call expire' do
-        subject.should_not_receive :expire
-        subject.should_not_receive :save
+        expect(subject).not_to receive :expire
+        expect(subject).not_to receive :save
         subject.expire!
       end
     end
@@ -177,15 +177,15 @@ describe Mailboxer::Notification do
       let(:now) { Time.now }
       let(:one_second_ago) { now - 1.second }
       before do
-        Time.stub(:now => now)
-        subject.stub(:expired? => false)
+        allow(Time).to receive(:now).and_return(now)
+        allow(subject).to receive(:expired?).and_return(false)
       end
       it 'should call expire' do
-        subject.should_receive(:expire)
+        expect(subject).to receive(:expire)
         subject.expire!
       end
       it 'should save the record' do
-        subject.should_receive :save
+        expect(subject).to receive :save
         subject.expire!
       end
     end
@@ -195,35 +195,35 @@ describe Mailboxer::Notification do
   describe "#expired?" do
     subject { described_class.new }
     context "when the expiration date is in the past" do
-      before { subject.stub(:expires => Time.now - 1.second) }
+      before { allow(subject).to receive(:expires).and_return(Time.now - 1.second) }
       it 'should be expired' do
-        subject.expired?.should be_true
+        expect(subject.expired?).to be true
       end
     end
 
     context "when the expiration date is now" do
       before {
         time = Time.now
-        Time.stub(:now => time)
-        subject.stub(:expires => time)
+        allow(Time).to receive(:now).and_return(time)
+        allow(subject).to receive(:expires).and_return(time)
       }
 
       it 'should not be expired' do
-        subject.expired?.should be_false
+        expect(subject.expired?).to be false
       end
     end
 
     context "when the expiration date is in the future" do
-      before { subject.stub(:expires => Time.now + 1.second) }
+      before { allow(subject).to receive(:expires).and_return(Time.now + 1.second) }
       it 'should not be expired' do
-        subject.expired?.should be_false
+        expect(subject.expired?).to be false
       end
     end
 
     context "when the expiration date is not set" do
-      before {subject.stub(:expires => nil)}
+      before { allow(subject).to receive(:expires).and_return(nil) }
       it 'should not be expired' do
-        subject.expired?.should be_false
+        expect(subject.expired?).to be false
       end
     end