mailboxer 0.11.0 → 0.12.0.rc1

data/spec/mailboxer/mail_dispatcher_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+describe Mailboxer::MailDispatcher do
+
+  subject(:instance) { described_class.new(mailable, recipients) }
+
+  let(:mailable)   { Mailboxer::Notification.new }
+  let(:recipient1) { double 'recipient1', mailboxer_email: ''  }
+  let(:recipient2) { double 'recipient2', mailboxer_email: 'foo@bar.com'  }
+  let(:recipients) { [ recipient1, recipient2 ] }
+
+  describe "call" do
+    context "no emails" do
+      before { Mailboxer.uses_emails = false }
+      after  { Mailboxer.uses_emails = true }
+      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)
+        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)
+        subject.call
+      end
+    end
+  end
+
+  describe "send_email" do
+
+    let(:mailer) { double 'mailer' }
+
+    before(:each) do
+      subject.stub(:mailer).and_return mailer
+    end
+
+    context "with custom_deliver_proc" do
+      let(:my_proc) { double 'proc' }
+
+      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)
+        subject.send :send_email, recipient1
+      end
+    end
+
+    context "without custom_deliver_proc" 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
+
+        subject.send :send_email, recipient1
+      end
+    end
+  end
+
+  describe "mailer" do
+    let(:recipients) { [] }
+
+    context "mailable is a Message" do
+      let(:mailable) { Mailboxer::Notification.new }
+
+      its(:mailer) { should be Mailboxer::NotificationMailer }
+
+      context "with custom mailer" do
+        before { Mailboxer.notification_mailer = 'foo' }
+        after  { Mailboxer.notification_mailer = nil   }
+
+        its(:mailer) { should eq 'foo' }
+      end
+    end
+
+    context "mailable is a Notification" do
+      let(:mailable) { Mailboxer::Message.new }
+      its(:mailer) { should be Mailboxer::MessageMailer }
+
+      context "with custom mailer" do
+        before { Mailboxer.message_mailer = 'foo' }
+        after  { Mailboxer.message_mailer = nil   }
+
+        its(:mailer) { should eq 'foo' }
+      end
+    end
+  end
+
+  describe "filtered_recipients" do
+    context "responds to conversation" 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
+      end
+
+      its(:filtered_recipients){ should eq [recipient2] }
+    end
+
+    context 'doesnt respond to conversation' do
+      let(:mailable) { double 'mailable' }
+      its(:filtered_recipients){ should eq recipients }
+    end
+  end
+end

data/spec/mailers/message_mailer_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe MessageMailer do
+describe Mailboxer::MessageMailer do
   shared_examples 'message_mailer' do
     let(:sender) { FactoryGirl.create(:user) }
     let(:entity1) { FactoryGirl.create(:user) }
@@ -66,8 +66,8 @@ describe MessageMailer do
   end
 
   context "mailer_wants_array is true" do
-    class ArrayMailer < MessageMailer
-      default template_path: 'message_mailer'
+    class ArrayMailer < Mailboxer::MessageMailer
+      default template_path: 'mailboxer/message_mailer'
 
       def new_message_email(message, receivers)
         receivers.each { |receiver| super(message, receiver) if receiver.mailboxer_email(message).present? }
@@ -85,7 +85,7 @@ describe MessageMailer do
 
     after :all do
       Mailboxer.mailer_wants_array = false
-      Mailboxer.message_mailer = MessageMailer
+      Mailboxer.message_mailer = Mailboxer::MessageMailer
     end
 
     it_behaves_like 'message_mailer'

data/spec/mailers/notification_mailer_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe NotificationMailer do
+describe Mailboxer::NotificationMailer do
   before do
     @entity1 = FactoryGirl.create(:user)
     @entity2 = FactoryGirl.create(:duck)
     @entity3 = FactoryGirl.create(:cylon)
-    @receipt1 = Notification.notify_all([@entity1,@entity2,@entity3],"Subject", "Body Body Body Body Body Body Body Body Body Body Body Body")
+    @receipt1 = Mailboxer::Notification.notify_all([@entity1,@entity2,@entity3],"Subject", "Body Body Body Body Body Body Body Body Body Body Body Body")
   end
 
   it "should send emails when should_email? is true (2 out of 3)" do

data/spec/models/conversation_spec.rb

@@ -1,123 +1,224 @@
 require 'spec_helper'
 
-describe Conversation do
+describe Mailboxer::Conversation do
 
-  before do
-    @entity1 = FactoryGirl.create(:user)
-    @entity2 = FactoryGirl.create(:user)
-    @receipt1 = @entity1.send_message(@entity2,"Body","Subject")
-    @receipt2 = @entity2.reply_to_all(@receipt1,"Reply body 1")
-    @receipt3 = @entity1.reply_to_all(@receipt2,"Reply body 2")
-    @receipt4 = @entity2.reply_to_all(@receipt3,"Reply body 3")
-    @message1 = @receipt1.notification
-    @message4 = @receipt4.notification
-    @conversation = @message1.conversation
-  end
+  let!(:entity1)  { FactoryGirl.create(:user) }
+  let!(:entity2)  { FactoryGirl.create(:user) }
+  let!(:receipt1) { entity1.send_message(entity2,"Body","Subject") }
+  let!(:receipt2) { entity2.reply_to_all(receipt1,"Reply body 1") }
+  let!(:receipt3) { entity1.reply_to_all(receipt2,"Reply body 2") }
+  let!(:receipt4) { entity2.reply_to_all(receipt3,"Reply body 3") }
+  let!(:message1) { receipt1.notification }
+  let!(:message4) { receipt4.notification }
+  let!(:conversation) { message1.conversation }
+
+  it { should validate_presence_of :subject }
+  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
+    conversation.original_message.should == message1
   end
 
   it "should have proper originator (first sender)" do
-    @conversation.originator.should==@entity1
+    conversation.originator.should == entity1
   end
 
   it "should have proper last message" do
-    @conversation.last_message.should==@message4
+    conversation.last_message.should == message4
   end
 
   it "should have proper last sender" do
-    @conversation.last_sender.should==@entity2
+    conversation.last_sender.should == 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
+    conversation.recipients.count.should == 2
+    conversation.recipients.count.should == 2
+    conversation.recipients.count(entity1).should == 1
+    conversation.recipients.count(entity2).should == 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)
+    conversation.move_to_trash(entity1)
+    conversation.mark_as_deleted(entity1)
+    conversation.should 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
   end
 
   it "should be able to be marked as read" do
-    #@conversation.move_to_trash(@entity1)
-    @conversation.mark_as_read(@entity1)
-    @conversation.should be_is_read(@entity)
+    conversation.mark_as_read(entity1)
+    conversation.should 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)
+    conversation.mark_as_read(entity1)
+    conversation.mark_as_unread(entity1)
+    conversation.should 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
+    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
   end
 
   it "should deliver messages to new participants" do
     new_user = FactoryGirl.create(:user)
-    @conversation.add_participant(new_user)
+    conversation.add_participant(new_user)
     expect{
-      receipt5 = @entity1.reply_to_all(@receipt4,"Reply body 4")
-    }.to change{ @conversation.receipts_for(new_user).count }.by 1
+      receipt5 = entity1.reply_to_all(receipt4,"Reply body 4")
+    }.to change{ conversation.receipts_for(new_user).count }.by 1
   end
 
   describe "scopes" do
     let(:participant) { FactoryGirl.create(:user) }
-    let!(:inbox_conversation) { @entity1.send_message(participant, "Body", "Subject").notification.conversation }
-    let!(:sentbox_conversation) { participant.send_message(@entity1, "Body", "Subject").notification.conversation }
+    let!(:inbox_conversation) { entity1.send_message(participant, "Body", "Subject").notification.conversation }
+    let!(:sentbox_conversation) { participant.send_message(entity1, "Body", "Subject").notification.conversation }
 
 
     describe ".participant" do
       it "finds conversations with receipts for participant" do
-        Conversation.participant(participant).should == [sentbox_conversation, inbox_conversation]
+        Mailboxer::Conversation.participant(participant).should == [sentbox_conversation, inbox_conversation]
       end
     end
 
     describe ".inbox" do
       it "finds inbox conversations with receipts for participant" do
-        Conversation.inbox(participant).should == [inbox_conversation]
+        Mailboxer::Conversation.inbox(participant).should == [inbox_conversation]
       end
     end
 
     describe ".sentbox" do
       it "finds sentbox conversations with receipts for participant" do
-        Conversation.sentbox(participant).should == [sentbox_conversation]
+        Mailboxer::Conversation.sentbox(participant).should == [sentbox_conversation]
       end
     end
 
     describe ".trash" do
       it "finds trash conversations with receipts for participant" do
-        trashed_conversation = @entity1.send_message(participant, "Body", "Subject").notification.conversation
+        trashed_conversation = entity1.send_message(participant, "Body", "Subject").notification.conversation
         trashed_conversation.move_to_trash(participant)
 
-        Conversation.trash(participant).should == [trashed_conversation]
+        Mailboxer::Conversation.trash(participant).should == [trashed_conversation]
       end
     end
 
     describe ".unread" do
       it "finds unread conversations with receipts for participant" do
         [sentbox_conversation, inbox_conversation].each {|c| c.mark_as_read(participant) }
-        unread_conversation = @entity1.send_message(participant, "Body", "Subject").notification.conversation
+        unread_conversation = entity1.send_message(participant, "Body", "Subject").notification.conversation
 
-        Conversation.unread(participant).should == [unread_conversation]
+        Mailboxer::Conversation.unread(participant).should == [unread_conversation]
       end
     end
   end
 
   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
+      conversation.move_to_trash(entity1)
+      conversation.is_completely_trashed?(entity1).should 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
+    end
+
+    it "returns true if a recipient has deleted the conversation" do
+      conversation.mark_as_deleted(entity1)
+      conversation.is_deleted?(entity1).should be_true
+    end
+  end
+
+  describe "#is_orphaned?" 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
+    end
+
+    it "returns false if one has not deleted the conversation" do
+      conversation.mark_as_deleted(entity1)
+      conversation.is_orphaned?.should be_false
+    end
+  end
+
+
+  describe "#opt_out" do
+    context 'participant still opt in' do
+      let(:opt_out) { conversation.opt_outs.first }
+
+      it "creates an opt_out object" do
+        expect{
+          conversation.opt_out(entity1)
+        }.to change{ conversation.opt_outs.count}.by 1
+      end
+
+      it "creates opt out object linked to the proper conversation and participant" do
+        conversation.opt_out(entity1)
+        expect(opt_out.conversation).to eq conversation
+        expect(opt_out.unsubscriber).to eq entity1
+      end
+    end
+
+    context 'participant already opted out' do
+      before do
+        conversation.opt_out(entity1)
+      end
+      it 'does nothing' do
+        expect{
+          conversation.opt_out(entity1)
+        }.to_not change{ conversation.opt_outs.count}
+      end
+    end
+  end
+
+  describe "#opt_out" do
+    context 'participant already opt in' do
+      it "does nothing" do
+        expect{
+          conversation.opt_in(entity1)
+        }.to_not change{ conversation.opt_outs.count }
+      end
+    end
+
+    context 'participant opted out' do
+      before do
+        conversation.opt_out(entity1)
+      end
+      it 'destroys the opt out object' do
+        expect{
+          conversation.opt_in(entity1)
+        }.to change{ conversation.opt_outs.count}.by -1
+      end
     end
   end
+
+  describe "#subscriber?" do
+    let(:action) { conversation.has_subscriber?(entity1) }
+
+    context 'participant opted in' do
+      it "returns true" do
+        expect(action).to be_true
+      end
+    end
+
+    context 'participant opted out' do
+      before do
+        conversation.opt_out(entity1)
+      end
+      it 'returns false' do
+        expect(action).to be_false
+      end
+    end
+  end
+
 end

data/spec/models/mailbox_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe Mailbox do
-  
+describe Mailboxer::Mailbox do
+
   before do
     @entity1 = FactoryGirl.create(:user)
     @entity2 = FactoryGirl.create(:user)
@@ -12,60 +12,60 @@ describe Mailbox do
     @message1 = @receipt1.notification
     @message4 = @receipt4.notification
     @conversation = @message1.conversation
-  end  
-  
+  end
+
   it "should return all conversations" do
     @conv2 = @entity1.send_message(@entity2,"Body","Subject").conversation
     @conv3 = @entity2.send_message(@entity1,"Body","Subject").conversation
     @conv4 =  @entity1.send_message(@entity2,"Body","Subject").conversation
-    
+
     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    
+        @entity1.mailbox.conversations.to_a.count(@conv4).should==1
   end
-  
-  it "should return all mail" do 
+
+  it "should return all mail" do
     assert @entity1.mailbox.receipts
     @entity1.mailbox.receipts.count.should==4
-    @entity1.mailbox.receipts[0].should==Receipt.recipient(@entity1).conversation(@conversation)[0]
-    @entity1.mailbox.receipts[1].should==Receipt.recipient(@entity1).conversation(@conversation)[1]
-    @entity1.mailbox.receipts[2].should==Receipt.recipient(@entity1).conversation(@conversation)[2]
-    @entity1.mailbox.receipts[3].should==Receipt.recipient(@entity1).conversation(@conversation)[3]
-    
+    @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]
+
     assert @entity2.mailbox.receipts
     @entity2.mailbox.receipts.count.should==4
-    @entity2.mailbox.receipts[0].should==Receipt.recipient(@entity2).conversation(@conversation)[0]
-    @entity2.mailbox.receipts[1].should==Receipt.recipient(@entity2).conversation(@conversation)[1]
-    @entity2.mailbox.receipts[2].should==Receipt.recipient(@entity2).conversation(@conversation)[2]
-    @entity2.mailbox.receipts[3].should==Receipt.recipient(@entity2).conversation(@conversation)[3]    
+    @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]
   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
-    
+
     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
   end
-  
+
   it "should return inbox" do
     assert @entity1.mailbox.receipts.inbox
     @entity1.mailbox.receipts.inbox.count.should==2
-    @entity1.mailbox.receipts.inbox[0].should==Receipt.recipient(@entity1).inbox.conversation(@conversation)[0]
-    @entity1.mailbox.receipts.inbox[1].should==Receipt.recipient(@entity1).inbox.conversation(@conversation)[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]
+
     assert @entity2.mailbox.receipts.inbox
     @entity2.mailbox.receipts.inbox.count.should==2
-    @entity2.mailbox.receipts.inbox[0].should==Receipt.recipient(@entity2).inbox.conversation(@conversation)[0]
-    @entity2.mailbox.receipts.inbox[1].should==Receipt.recipient(@entity2).inbox.conversation(@conversation)[1]
+    @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]
   end
 
   it "should understand the read option" do
@@ -73,41 +73,41 @@ describe Mailbox do
     @conversation.mark_as_read(@entity1)
     @entity1.mailbox.inbox({:read => false}).count.should == 0
   end
-  
-  it "should return trashed mails" do 
+
+  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==Receipt.recipient(@entity1).conversation(@conversation)[0]
-    @entity1.mailbox.receipts.trash[1].should==Receipt.recipient(@entity1).conversation(@conversation)[1]
-    @entity1.mailbox.receipts.trash[2].should==Receipt.recipient(@entity1).conversation(@conversation)[2]
-    @entity1.mailbox.receipts.trash[3].should==Receipt.recipient(@entity1).conversation(@conversation)[3]
-    
+    @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]
+
     assert @entity2.mailbox.receipts.trash
-    @entity2.mailbox.receipts.trash.count.should==0    
+    @entity2.mailbox.receipts.trash.count.should==0
   end
-  
-  it "should delete trashed mails (TODO)" do 
+
+  it "should delete trashed mails (TODO)" do
     @entity1.mailbox.receipts.move_to_trash
     #TODO
     #@entity1.mailbox.empty_trash
-    
+
     assert @entity1.mailbox.receipts.trash
-    #@entity1.mailbox.receipts.trash.count.should==0    
-    
+    #@entity1.mailbox.receipts.trash.count.should==0
+
     assert @entity2.mailbox.receipts
     @entity2.mailbox.receipts.count.should==4
-    
+
     assert @entity2.mailbox.receipts.trash
-    @entity2.mailbox.receipts.trash.count.should==0    
+    @entity2.mailbox.receipts.trash.count.should==0
   end
 
   it "should deleted messages are not shown in inbox" do
     assert @entity1.mailbox.receipts.inbox
-    @entity1.mailbox.inbox.count.should==2
-    @entity1.mailbox.receipts.inbox[0].should==Receipt.recipient(@entity1).inbox.conversation(@conversation)[0]
-    @entity1.mailbox.receipts.inbox[1].should==Receipt.recipient(@entity1).inbox.conversation(@conversation)[1]
+    @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]
 
     assert @entity1.mailbox.receipts.inbox.mark_as_deleted
     @entity1.mailbox.inbox.count.should==0
@@ -125,9 +125,9 @@ describe Mailbox do
 
   it "should reply for deleted messages return to inbox" do
     assert @entity1.mailbox.receipts.inbox
-    @entity1.mailbox.inbox.count.should==2
-    @entity1.mailbox.receipts.inbox[0].should==Receipt.recipient(@entity1).inbox.conversation(@conversation)[0]
-    @entity1.mailbox.receipts.inbox[1].should==Receipt.recipient(@entity1).inbox.conversation(@conversation)[1]
+    @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]
 
     assert @entity1.mailbox.receipts.inbox.mark_as_deleted
     @entity1.mailbox.inbox.count.should==0
@@ -136,7 +136,7 @@ describe Mailbox do
     @entity1.mailbox.inbox.count.should==1
 
     @entity2.reply_to_all(@receipt3,"Reply body 3")
-    @entity1.mailbox.inbox.count.should==2
+    @entity1.mailbox.inbox.count.should==1
   end
 
   context "STI models" do
@@ -156,5 +156,5 @@ describe Mailbox do
       @sti_entity2.mailbox.inbox.should include(@sti_mail.conversation)
     end
   end
-  
+
 end