refactor: move senders in to app/senders/

spec/lib/message_dequeuer/incoming_message_processor_spec.rb

@@ -409,8 +409,8 @@ module MessageDequeuer
 
       it "gets a sender from the state and sends the message to it" do
         http_sender_double = double("HTTPSender")
-        expect(http_sender_double).to receive(:send_message).with(queued_message.message).and_return(Postal::SendResult.new)
-        expect(state).to receive(:sender_for).with(Postal::HTTPSender, endpoint).and_return(http_sender_double)
+        expect(http_sender_double).to receive(:send_message).with(queued_message.message).and_return(SendResult.new)
+        expect(state).to receive(:sender_for).with(HTTPSender, endpoint).and_return(http_sender_double)
         processor.process
       end
     end
@@ -421,8 +421,8 @@ module MessageDequeuer
 
       it "gets a sender from the state and sends the message to it" do
         smtp_sender_double = double("SMTPSender")
-        expect(smtp_sender_double).to receive(:send_message).with(queued_message.message).and_return(Postal::SendResult.new)
-        expect(state).to receive(:sender_for).with(Postal::SMTPSender, message.recipient_domain, nil, { servers: [endpoint] }).and_return(smtp_sender_double)
+        expect(smtp_sender_double).to receive(:send_message).with(queued_message.message).and_return(SendResult.new)
+        expect(state).to receive(:sender_for).with(SMTPSender, message.recipient_domain, nil, { servers: [endpoint] }).and_return(smtp_sender_double)
         processor.process
       end
     end
@@ -433,8 +433,8 @@ module MessageDequeuer
 
       it "gets a sender from the state and sends the message to it" do
         smtp_sender_double = double("SMTPSender")
-        expect(smtp_sender_double).to receive(:send_message).with(queued_message.message).and_return(Postal::SendResult.new)
-        expect(state).to receive(:sender_for).with(Postal::SMTPSender, endpoint.domain, nil, { force_rcpt_to: endpoint.address }).and_return(smtp_sender_double)
+        expect(smtp_sender_double).to receive(:send_message).with(queued_message.message).and_return(SendResult.new)
+        expect(state).to receive(:sender_for).with(SMTPSender, endpoint.domain, nil, { force_rcpt_to: endpoint.address }).and_return(smtp_sender_double)
         processor.process
       end
     end
@@ -469,7 +469,7 @@ module MessageDequeuer
       let(:route) { create(:route, server: server, mode: "Endpoint", endpoint: endpoint) }
 
       let(:send_result) do
-        Postal::SendResult.new do |result|
+        SendResult.new do |result|
           result.type = "Sent"
           result.details = "Sent successfully"
         end
@@ -477,7 +477,7 @@ module MessageDequeuer
 
       before do
         smtp_sender_mock = double("SMTPSender")
-        allow(Postal::SMTPSender).to receive(:new).and_return(smtp_sender_mock)
+        allow(SMTPSender).to receive(:new).and_return(smtp_sender_mock)
         allow(smtp_sender_mock).to receive(:start)
         allow(smtp_sender_mock).to receive(:finish)
         allow(smtp_sender_mock).to receive(:send_message).and_return(send_result)
@@ -611,7 +611,7 @@ module MessageDequeuer
 
       before do
         smtp_sender_mock = double("SMTPSender")
-        allow(Postal::SMTPSender).to receive(:new).and_return(smtp_sender_mock)
+        allow(SMTPSender).to receive(:new).and_return(smtp_sender_mock)
         allow(smtp_sender_mock).to receive(:start)
         allow(smtp_sender_mock).to receive(:finish)
         allow(smtp_sender_mock).to receive(:send_message) do

spec/lib/message_dequeuer/outgoing_message_processor_spec.rb

@@ -361,7 +361,7 @@ module MessageDequeuer
 
     context "when there are no other impediments" do
       let(:send_result) do
-        Postal::SendResult.new do |r|
+        SendResult.new do |r|
           r.type = "Sent"
         end
       end
@@ -383,7 +383,7 @@ module MessageDequeuer
         it "gets a sender from the state and sends the message to it" do
           mocked_sender = double("SMTPSender")
           expect(mocked_sender).to receive(:send_message).with(queued_message.message).and_return(send_result)
-          expect(state).to receive(:sender_for).with(Postal::SMTPSender, message.recipient_domain, ip).and_return(mocked_sender)
+          expect(state).to receive(:sender_for).with(SMTPSender, message.recipient_domain, ip).and_return(mocked_sender)
 
           processor.process
         end
@@ -393,7 +393,7 @@ module MessageDequeuer
         it "gets a sender from the state and sends the message to it" do
           mocked_sender = double("SMTPSender")
           expect(mocked_sender).to receive(:send_message).with(queued_message.message).and_return(send_result)
-          expect(state).to receive(:sender_for).with(Postal::SMTPSender, message.recipient_domain, nil).and_return(mocked_sender)
+          expect(state).to receive(:sender_for).with(SMTPSender, message.recipient_domain, nil).and_return(mocked_sender)
 
           processor.process
         end
@@ -514,7 +514,7 @@ module MessageDequeuer
     context "when an exception occurrs during processing" do
       before do
         smtp_sender_mock = double("SMTPSender")
-        allow(Postal::SMTPSender).to receive(:new).and_return(smtp_sender_mock)
+        allow(SMTPSender).to receive(:new).and_return(smtp_sender_mock)
         allow(smtp_sender_mock).to receive(:start)
         allow(smtp_sender_mock).to receive(:send_message) do
           1 / 0

spec/lib/message_dequeuer/state_spec.rb

@@ -9,7 +9,7 @@ module MessageDequeuer
 
     describe "#send_result" do
       it "can be get and set" do
-        result = instance_double(Postal::SendResult)
+        result = instance_double(SendResult)
         state.send_result = result
         expect(state.send_result).to be result
       end
@@ -17,20 +17,20 @@ module MessageDequeuer
 
     describe "#sender_for" do
       it "returns a instance of the given sender initialized with the args" do
-        sender = state.sender_for(Postal::HTTPSender, "1234")
-        expect(sender).to be_a Postal::HTTPSender
+        sender = state.sender_for(HTTPSender, "1234")
+        expect(sender).to be_a HTTPSender
       end
 
       it "returns a cached sender on subsequent calls" do
-        sender = state.sender_for(Postal::HTTPSender, "1234")
-        expect(state.sender_for(Postal::HTTPSender, "1234")).to be sender
+        sender = state.sender_for(HTTPSender, "1234")
+        expect(state.sender_for(HTTPSender, "1234")).to be sender
       end
     end
 
     describe "#finished" do
       it "calls finish on all cached senders" do
-        sender1 = state.sender_for(Postal::HTTPSender, "1234")
-        sender2 = state.sender_for(Postal::HTTPSender, "4444")
+        sender1 = state.sender_for(HTTPSender, "1234")
+        sender2 = state.sender_for(HTTPSender, "4444")
         expect(sender1).to receive(:finish)
         expect(sender2).to receive(:finish)