mailboxer 0.12.4 → 0.12.5

data/spec/integration/navigation_spec.rb

@@ -1,9 +1,8 @@
 require 'spec_helper'
 
 describe "Navigation" do
-  include Capybara::DSL
-  
+
   it "should be a valid app" do
-    ::Rails.application.should be_a(Dummy::Application)
+    expect(::Rails.application).to be_a(Dummy::Application)
   end
 end

data/spec/mailboxer/mail_dispatcher_spec.rb

@@ -13,22 +13,22 @@ describe Mailboxer::MailDispatcher do
     context "no emails" do
       before { Mailboxer.uses_emails = false }
       after  { Mailboxer.uses_emails = true }
-      its(:call) { should be_false }
+      its(:call) { should be false }
     end
 
     context "mailer wants array" do
       before { Mailboxer.mailer_wants_array = true  }
       after  { Mailboxer.mailer_wants_array = false }
       it 'sends collection' do
-        subject.should_receive(:send_email).with(recipients)
+        expect(subject).to receive(:send_email).with(recipients)
         subject.call
       end
     end
 
     context "mailer doesnt want array" do
       it 'sends collection' do
-        subject.should_not_receive(:send_email).with(recipient1) #email is blank
-        subject.should_receive(:send_email).with(recipient2)
+        expect(subject).not_to receive(:send_email).with(recipient1) #email is blank
+        expect(subject).to receive(:send_email).with(recipient2)
         subject.call
       end
     end
@@ -39,7 +39,7 @@ describe Mailboxer::MailDispatcher do
     let(:mailer) { double 'mailer' }
 
     before(:each) do
-      subject.stub(:mailer).and_return mailer
+      allow(subject).to receive(:mailer).and_return mailer
     end
 
     context "with custom_deliver_proc" do
@@ -48,7 +48,7 @@ describe Mailboxer::MailDispatcher do
       before { Mailboxer.custom_deliver_proc = my_proc }
       after  { Mailboxer.custom_deliver_proc = nil     }
       it "triggers proc" do
-        my_proc.should_receive(:call).with(mailer, mailable, recipient1)
+        expect(my_proc).to receive(:call).with(mailer, mailable, recipient1)
         subject.send :send_email, recipient1
       end
     end
@@ -57,8 +57,8 @@ describe Mailboxer::MailDispatcher do
       let(:email) { double :email }
 
       it "triggers standard deliver chain" do
-        mailer.should_receive(:send_email).with(mailable, recipient1).and_return email
-        email.should_receive :deliver
+        expect(mailer).to receive(:send_email).with(mailable, recipient1).and_return email
+        expect(email).to receive :deliver
 
         subject.send :send_email, recipient1
       end
@@ -99,8 +99,8 @@ describe Mailboxer::MailDispatcher do
       let(:conversation) { double 'conversation' }
       let(:mailable)     { double 'mailable', :conversation => conversation }
       before(:each) do
-        conversation.should_receive(:has_subscriber?).with(recipient1).and_return false
-        conversation.should_receive(:has_subscriber?).with(recipient2).and_return true
+        expect(conversation).to receive(:has_subscriber?).with(recipient1).and_return false
+        expect(conversation).to receive(:has_subscriber?).with(recipient2).and_return true
       end
 
       its(:filtered_recipients){ should eq [recipient2] }

data/spec/mailboxer_spec.rb

@@ -2,6 +2,6 @@ require 'spec_helper'
 
 describe Mailboxer do
   it "should be valid" do
-    Mailboxer.should be_a(Module)
+    expect(Mailboxer).to be_a(Module)
   end
 end

data/spec/mailers/message_mailer_spec.rb

@@ -19,20 +19,20 @@ describe Mailboxer::MessageMailer do
       end
 
       it "should send emails when should_email? is true (1 out of 3)" do
-        ActionMailer::Base.deliveries.should_not be_empty
-        ActionMailer::Base.deliveries.should have(1).item
+        expect(ActionMailer::Base.deliveries).not_to be_empty
+        expect(ActionMailer::Base.deliveries).to have(1).item
       end
 
       it "should send an email to user entity" do
-        sent_to?(entity1).should be_true
+        expect(sent_to?(entity1)).to be true
       end
 
       it "shouldn't send an email to duck entity" do
-        sent_to?(entity2).should be_false
+        expect(sent_to?(entity2)).to be false
       end
 
       it "shouldn't send an email to cylon entity" do
-        sent_to?(entity3).should be_false
+        expect(sent_to?(entity3)).to be false
       end
     end
 
@@ -43,20 +43,20 @@ describe Mailboxer::MessageMailer do
       end
 
       it "should send emails when should_email? is true (1 out of 3)" do
-        ActionMailer::Base.deliveries.should_not be_empty
-        ActionMailer::Base.deliveries.should have(2).items
+        expect(ActionMailer::Base.deliveries).not_to be_empty
+        expect(ActionMailer::Base.deliveries).to have(2).items
       end
 
       it "should send an email to user entity" do
-        sent_to?(entity1).should be_true
+        expect(sent_to?(entity1)).to be true
       end
 
       it "shouldn't send an email to duck entity" do
-        sent_to?(entity2).should be_false
+        expect(sent_to?(entity2)).to be false
       end
 
       it "shouldn't send an email to cylon entity" do
-        sent_to?(entity3).should be_false
+        expect(sent_to?(entity3)).to be false
       end
     end
   end

data/spec/mailers/notification_mailer_spec.rb

@@ -9,8 +9,7 @@ describe Mailboxer::NotificationMailer do
   end
 
   it "should send emails when should_email? is true (2 out of 3)" do
-    ActionMailer::Base.deliveries.empty?.should==false
-    ActionMailer::Base.deliveries.size.should==2
+    expect(ActionMailer::Base.deliveries.size).to eq 2
   end
 
   it "should send an email to user entity" do
@@ -20,7 +19,7 @@ describe Mailboxer::NotificationMailer do
       temp = true
       end
     end
-    temp.should==true
+    expect(temp).to be true
   end
 
   it "should send an email to duck entity" do
@@ -30,7 +29,7 @@ describe Mailboxer::NotificationMailer do
       temp = true
       end
     end
-    temp.should==true
+    expect(temp).to be true
   end
 
   it "shouldn't send an email to cylon entity" do
@@ -40,7 +39,7 @@ describe Mailboxer::NotificationMailer do
       temp = true
       end
     end
-    temp.should==false
+    expect(temp).to be false
   end
 end
 

data/spec/models/conversation_spec.rb

@@ -16,57 +16,57 @@ describe Mailboxer::Conversation do
   it { should ensure_length_of(:subject).is_at_most(Mailboxer.subject_max_length) }
 
   it "should have proper original message" do
-    conversation.original_message.should == message1
+    expect(conversation.original_message).to eq message1
   end
 
   it "should have proper originator (first sender)" do
-    conversation.originator.should == entity1
+    expect(conversation.originator).to eq entity1
   end
 
   it "should have proper last message" do
-    conversation.last_message.should == message4
+    expect(conversation.last_message).to eq message4
   end
 
   it "should have proper last sender" do
-    conversation.last_sender.should == entity2
+    expect(conversation.last_sender).to eq entity2
   end
 
   it "should have all conversation users" do
-    conversation.recipients.count.should == 2
-    conversation.recipients.count.should == 2
-    conversation.recipients.count(entity1).should == 1
-    conversation.recipients.count(entity2).should == 1
+    expect(conversation.recipients.count).to eq 2
+    expect(conversation.recipients.count).to eq 2
+    expect(conversation.recipients.count(entity1)).to eq 1
+    expect(conversation.recipients.count(entity2)).to eq 1
   end
 
   it "should be able to be marked as deleted" do
     conversation.move_to_trash(entity1)
     conversation.mark_as_deleted(entity1)
-    conversation.should be_is_deleted(entity1)
+    expect(conversation).to be_is_deleted(entity1)
   end
 
   it "should be removed from the database once deleted by all participants" do
     conversation.mark_as_deleted(entity1)
     conversation.mark_as_deleted(entity2)
-    Mailboxer::Conversation.exists?(conversation.id).should be_false
+    expect(Mailboxer::Conversation.exists?(conversation.id)).to be false
   end
 
   it "should be able to be marked as read" do
     conversation.mark_as_read(entity1)
-    conversation.should be_is_read(entity1)
+    expect(conversation).to be_is_read(entity1)
   end
 
   it "should be able to be marked as unread" do
     conversation.mark_as_read(entity1)
     conversation.mark_as_unread(entity1)
-    conversation.should be_is_unread(entity1)
+    expect(conversation).to be_is_unread(entity1)
   end
 
   it "should be able to add a new participant" do
     new_user = FactoryGirl.create(:user)
     conversation.add_participant(new_user)
-    conversation.participants.count.should == 3
-    conversation.participants.should include(new_user, entity1, entity2)
-    conversation.receipts_for(new_user).count.should == conversation.receipts_for(entity1).count
+    expect(conversation.participants.count).to eq 3
+    expect(conversation.participants).to include(new_user, entity1, entity2)
+    expect(conversation.receipts_for(new_user).count).to eq conversation.receipts_for(entity1).count
   end
 
   it "should deliver messages to new participants" do
@@ -85,19 +85,19 @@ describe Mailboxer::Conversation do
 
     describe ".participant" do
       it "finds conversations with receipts for participant" do
-        Mailboxer::Conversation.participant(participant).should == [sentbox_conversation, inbox_conversation]
+        expect(Mailboxer::Conversation.participant(participant)).to eq [sentbox_conversation, inbox_conversation]
       end
     end
 
     describe ".inbox" do
       it "finds inbox conversations with receipts for participant" do
-        Mailboxer::Conversation.inbox(participant).should == [inbox_conversation]
+        expect(Mailboxer::Conversation.inbox(participant)).to eq [inbox_conversation]
       end
     end
 
     describe ".sentbox" do
       it "finds sentbox conversations with receipts for participant" do
-        Mailboxer::Conversation.sentbox(participant).should == [sentbox_conversation]
+        expect(Mailboxer::Conversation.sentbox(participant)).to eq [sentbox_conversation]
       end
     end
 
@@ -106,7 +106,7 @@ describe Mailboxer::Conversation do
         trashed_conversation = entity1.send_message(participant, "Body", "Subject").notification.conversation
         trashed_conversation.move_to_trash(participant)
 
-        Mailboxer::Conversation.trash(participant).should == [trashed_conversation]
+        expect(Mailboxer::Conversation.trash(participant)).to eq [trashed_conversation]
       end
     end
 
@@ -115,7 +115,7 @@ describe Mailboxer::Conversation do
         [sentbox_conversation, inbox_conversation].each {|c| c.mark_as_read(participant) }
         unread_conversation = entity1.send_message(participant, "Body", "Subject").notification.conversation
 
-        Mailboxer::Conversation.unread(participant).should == [unread_conversation]
+        expect(Mailboxer::Conversation.unread(participant)).to eq [unread_conversation]
       end
     end
   end
@@ -123,18 +123,18 @@ describe Mailboxer::Conversation do
   describe "#is_completely_trashed?" do
     it "returns true if all receipts in conversation are trashed for participant" do
       conversation.move_to_trash(entity1)
-      conversation.is_completely_trashed?(entity1).should be_true
+      expect(conversation.is_completely_trashed?(entity1)).to be true
     end
   end
 
   describe "#is_deleted?" do
     it "returns false if a recipient has not deleted the conversation" do
-      conversation.is_deleted?(entity1).should be_false
+      expect(conversation.is_deleted?(entity1)).to be false
     end
 
     it "returns true if a recipient has deleted the conversation" do
       conversation.mark_as_deleted(entity1)
-      conversation.is_deleted?(entity1).should be_true
+      expect(conversation.is_deleted?(entity1)).to be true
     end
   end
 
@@ -142,12 +142,12 @@ describe Mailboxer::Conversation do
     it "returns true if both participants have deleted the conversation" do
       conversation.mark_as_deleted(entity1)
       conversation.mark_as_deleted(entity2)
-      conversation.is_orphaned?.should be_true
+      expect(conversation.is_orphaned?).to be true
     end
 
     it "returns false if one has not deleted the conversation" do
       conversation.mark_as_deleted(entity1)
-      conversation.is_orphaned?.should be_false
+      expect(conversation.is_orphaned?).to be false
     end
   end
 
@@ -207,7 +207,7 @@ describe Mailboxer::Conversation do
 
     context 'participant opted in' do
       it "returns true" do
-        expect(action).to be_true
+        expect(action).to be true
       end
     end
 
@@ -216,7 +216,7 @@ describe Mailboxer::Conversation do
         conversation.opt_out(entity1)
       end
       it 'returns false' do
-        expect(action).to be_false
+        expect(action).to be false
       end
     end
   end

data/spec/models/mailbox_spec.rb

@@ -21,71 +21,71 @@ describe Mailboxer::Mailbox do
 
     assert @entity1.mailbox.conversations
 
-    @entity1.mailbox.conversations.to_a.count.should==4
-        @entity1.mailbox.conversations.to_a.count(@conversation).should==1
-        @entity1.mailbox.conversations.to_a.count(@conv2).should==1
-        @entity1.mailbox.conversations.to_a.count(@conv3).should==1
-        @entity1.mailbox.conversations.to_a.count(@conv4).should==1
+    expect(@entity1.mailbox.conversations.to_a.count).to eq 4
+        expect(@entity1.mailbox.conversations.to_a.count(@conversation)).to eq 1
+        expect(@entity1.mailbox.conversations.to_a.count(@conv2)).to eq 1
+        expect(@entity1.mailbox.conversations.to_a.count(@conv3)).to eq 1
+        expect(@entity1.mailbox.conversations.to_a.count(@conv4)).to eq 1
   end
 
   it "should return all mail" do
     assert @entity1.mailbox.receipts
-    @entity1.mailbox.receipts.count.should==4
-    @entity1.mailbox.receipts[0].should==Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[0]
-    @entity1.mailbox.receipts[1].should==Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[1]
-    @entity1.mailbox.receipts[2].should==Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[2]
-    @entity1.mailbox.receipts[3].should==Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[3]
+    expect(@entity1.mailbox.receipts.count).to eq 4
+    expect(@entity1.mailbox.receipts[0]).to eq Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[0]
+    expect(@entity1.mailbox.receipts[1]).to eq Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[1]
+    expect(@entity1.mailbox.receipts[2]).to eq Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[2]
+    expect(@entity1.mailbox.receipts[3]).to eq Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[3]
 
     assert @entity2.mailbox.receipts
-    @entity2.mailbox.receipts.count.should==4
-    @entity2.mailbox.receipts[0].should==Mailboxer::Receipt.recipient(@entity2).conversation(@conversation)[0]
-    @entity2.mailbox.receipts[1].should==Mailboxer::Receipt.recipient(@entity2).conversation(@conversation)[1]
-    @entity2.mailbox.receipts[2].should==Mailboxer::Receipt.recipient(@entity2).conversation(@conversation)[2]
-    @entity2.mailbox.receipts[3].should==Mailboxer::Receipt.recipient(@entity2).conversation(@conversation)[3]
+    expect(@entity2.mailbox.receipts.count).to eq 4
+    expect(@entity2.mailbox.receipts[0]).to eq Mailboxer::Receipt.recipient(@entity2).conversation(@conversation)[0]
+    expect(@entity2.mailbox.receipts[1]).to eq Mailboxer::Receipt.recipient(@entity2).conversation(@conversation)[1]
+    expect(@entity2.mailbox.receipts[2]).to eq Mailboxer::Receipt.recipient(@entity2).conversation(@conversation)[2]
+    expect(@entity2.mailbox.receipts[3]).to eq Mailboxer::Receipt.recipient(@entity2).conversation(@conversation)[3]
   end
 
   it "should return sentbox" do
     assert @entity1.mailbox.receipts.inbox
-    @entity1.mailbox.receipts.sentbox.count.should==2
-    @entity1.mailbox.receipts.sentbox[0].should==@receipt1
-    @entity1.mailbox.receipts.sentbox[1].should==@receipt3
+    expect(@entity1.mailbox.receipts.sentbox.count).to eq 2
+    expect(@entity1.mailbox.receipts.sentbox[0]).to eq @receipt1
+    expect(@entity1.mailbox.receipts.sentbox[1]).to eq @receipt3
 
     assert @entity2.mailbox.receipts.inbox
-    @entity2.mailbox.receipts.sentbox.count.should==2
-    @entity2.mailbox.receipts.sentbox[0].should==@receipt2
-    @entity2.mailbox.receipts.sentbox[1].should==@receipt4
+    expect(@entity2.mailbox.receipts.sentbox.count).to eq 2
+    expect(@entity2.mailbox.receipts.sentbox[0]).to eq @receipt2
+    expect(@entity2.mailbox.receipts.sentbox[1]).to eq @receipt4
   end
 
   it "should return inbox" do
     assert @entity1.mailbox.receipts.inbox
-    @entity1.mailbox.receipts.inbox.count.should==2
-    @entity1.mailbox.receipts.inbox[0].should==Mailboxer::Receipt.recipient(@entity1).inbox.conversation(@conversation)[0]
-    @entity1.mailbox.receipts.inbox[1].should==Mailboxer::Receipt.recipient(@entity1).inbox.conversation(@conversation)[1]
+    expect(@entity1.mailbox.receipts.inbox.count).to eq 2
+    expect(@entity1.mailbox.receipts.inbox[0]).to eq Mailboxer::Receipt.recipient(@entity1).inbox.conversation(@conversation)[0]
+    expect(@entity1.mailbox.receipts.inbox[1]).to eq Mailboxer::Receipt.recipient(@entity1).inbox.conversation(@conversation)[1]
 
     assert @entity2.mailbox.receipts.inbox
-    @entity2.mailbox.receipts.inbox.count.should==2
-    @entity2.mailbox.receipts.inbox[0].should==Mailboxer::Receipt.recipient(@entity2).inbox.conversation(@conversation)[0]
-    @entity2.mailbox.receipts.inbox[1].should==Mailboxer::Receipt.recipient(@entity2).inbox.conversation(@conversation)[1]
+    expect(@entity2.mailbox.receipts.inbox.count).to eq 2
+    expect(@entity2.mailbox.receipts.inbox[0]).to eq Mailboxer::Receipt.recipient(@entity2).inbox.conversation(@conversation)[0]
+    expect(@entity2.mailbox.receipts.inbox[1]).to eq Mailboxer::Receipt.recipient(@entity2).inbox.conversation(@conversation)[1]
   end
 
   it "should understand the read option" do
-    @entity1.mailbox.inbox({:read => false}).count.should_not == 0
+    expect(@entity1.mailbox.inbox({:read => false}).count).not_to eq 0
     @conversation.mark_as_read(@entity1)
-    @entity1.mailbox.inbox({:read => false}).count.should == 0
+    expect(@entity1.mailbox.inbox({:read => false}).count).to eq 0
   end
 
   it "should return trashed mails" do
     @entity1.mailbox.receipts.move_to_trash
 
     assert @entity1.mailbox.receipts.trash
-    @entity1.mailbox.receipts.trash.count.should==4
-    @entity1.mailbox.receipts.trash[0].should==Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[0]
-    @entity1.mailbox.receipts.trash[1].should==Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[1]
-    @entity1.mailbox.receipts.trash[2].should==Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[2]
-    @entity1.mailbox.receipts.trash[3].should==Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[3]
+    expect(@entity1.mailbox.receipts.trash.count).to eq 4
+    expect(@entity1.mailbox.receipts.trash[0]).to eq Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[0]
+    expect(@entity1.mailbox.receipts.trash[1]).to eq Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[1]
+    expect(@entity1.mailbox.receipts.trash[2]).to eq Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[2]
+    expect(@entity1.mailbox.receipts.trash[3]).to eq Mailboxer::Receipt.recipient(@entity1).conversation(@conversation)[3]
 
     assert @entity2.mailbox.receipts.trash
-    @entity2.mailbox.receipts.trash.count.should==0
+    expect(@entity2.mailbox.receipts.trash.count).to eq 0
   end
 
   it "should delete trashed mails" do
@@ -93,49 +93,49 @@ describe Mailboxer::Mailbox do
     @entity1.mailbox.empty_trash
 
     assert @entity1.mailbox.receipts.trash
-    @entity1.mailbox.receipts.trash.count.should==0
+    expect(@entity1.mailbox.receipts.trash.count).to eq 0
 
     assert @entity2.mailbox.receipts
-    @entity2.mailbox.receipts.count.should==4
+    expect(@entity2.mailbox.receipts.count).to eq 4
 
     assert @entity2.mailbox.receipts.trash
-    @entity2.mailbox.receipts.trash.count.should==0
+    expect(@entity2.mailbox.receipts.trash.count).to eq 0
   end
 
   it "should deleted messages are not shown in inbox" do
     assert @entity1.mailbox.receipts.inbox
-    @entity1.mailbox.inbox.count.should==1
-    @entity1.mailbox.receipts.inbox[0].should==Mailboxer::Receipt.recipient(@entity1).inbox.conversation(@conversation)[0]
-    @entity1.mailbox.receipts.inbox[1].should==Mailboxer::Receipt.recipient(@entity1).inbox.conversation(@conversation)[1]
+    expect(@entity1.mailbox.inbox.count).to eq 1
+    expect(@entity1.mailbox.receipts.inbox[0]).to eq Mailboxer::Receipt.recipient(@entity1).inbox.conversation(@conversation)[0]
+    expect(@entity1.mailbox.receipts.inbox[1]).to eq Mailboxer::Receipt.recipient(@entity1).inbox.conversation(@conversation)[1]
 
     assert @entity1.mailbox.receipts.inbox.mark_as_deleted
-    @entity1.mailbox.inbox.count.should==0
+    expect(@entity1.mailbox.inbox.count).to eq 0
   end
 
   it "should deleted messages are not shown in sentbox" do
     assert @entity1.mailbox.receipts.inbox
-    @entity1.mailbox.receipts.sentbox.count.should==2
-    @entity1.mailbox.receipts.sentbox[0].should==@receipt1
-    @entity1.mailbox.receipts.sentbox[1].should==@receipt3
+    expect(@entity1.mailbox.receipts.sentbox.count).to eq 2
+    expect(@entity1.mailbox.receipts.sentbox[0]).to eq @receipt1
+    expect(@entity1.mailbox.receipts.sentbox[1]).to eq @receipt3
 
     assert @entity1.mailbox.receipts.sentbox.mark_as_deleted
-    @entity1.mailbox.sentbox.count.should==0
+    expect(@entity1.mailbox.sentbox.count).to eq 0
   end
 
   it "should reply for deleted messages return to inbox" do
     assert @entity1.mailbox.receipts.inbox
-    @entity1.mailbox.inbox.count.should==1
-    @entity1.mailbox.receipts.inbox[0].should==Mailboxer::Receipt.recipient(@entity1).inbox.conversation(@conversation)[0]
-    @entity1.mailbox.receipts.inbox[1].should==Mailboxer::Receipt.recipient(@entity1).inbox.conversation(@conversation)[1]
+    expect(@entity1.mailbox.inbox.count).to eq 1
+    expect(@entity1.mailbox.receipts.inbox[0]).to eq Mailboxer::Receipt.recipient(@entity1).inbox.conversation(@conversation)[0]
+    expect(@entity1.mailbox.receipts.inbox[1]).to eq Mailboxer::Receipt.recipient(@entity1).inbox.conversation(@conversation)[1]
 
     assert @entity1.mailbox.receipts.inbox.mark_as_deleted
-    @entity1.mailbox.inbox.count.should==0
+    expect(@entity1.mailbox.inbox.count).to eq 0
 
     @entity2.reply_to_all(@receipt1,"Reply body 1")
-    @entity1.mailbox.inbox.count.should==1
+    expect(@entity1.mailbox.inbox.count).to eq 1
 
     @entity2.reply_to_all(@receipt3,"Reply body 3")
-    @entity1.mailbox.inbox.count.should==1
+    expect(@entity1.mailbox.inbox.count).to eq 1
   end
 
   context "STI models" do
@@ -146,13 +146,13 @@ describe Mailboxer::Mailbox do
     end
 
     it "should add one to senders sentbox" do
-      @sti_entity1.mailbox.sentbox.count.should==1
-      @sti_entity1.mailbox.sentbox.should include(@sti_mail.conversation)
+      expect(@sti_entity1.mailbox.sentbox.count).to eq 1
+      expect(@sti_entity1.mailbox.sentbox).to include(@sti_mail.conversation)
     end
 
     it "should add one to recievers inbox" do
-      @sti_entity2.mailbox.inbox.count.should == 1
-      @sti_entity2.mailbox.inbox.should include(@sti_mail.conversation)
+      expect(@sti_entity2.mailbox.inbox.count).to eq 1
+      expect(@sti_entity2.mailbox.inbox).to include(@sti_mail.conversation)
     end
   end