test: additional tests for batched messages when unqueueing messages

app/services/unqueue_message_service.rb

@@ -464,6 +464,7 @@ class UnqueueMessageService
 
     # Log the result
     queued_message.message.create_delivery(result.type, details: result.details, output: result.output, sent_with_ssl: result.secure, log_id: result.log_id, time: result.time)
+
     if result.retry
       queued_message.retry_later(result.retry.is_a?(Integer) ? result.retry : nil)
       log "message requeued for trying later", retry_after: queued_message.retry_after

spec/app/services/unqueue_message_service_spec.rb

@@ -28,8 +28,71 @@ RSpec.describe UnqueueMessageService do
     end
 
     context "when there are other messages to batch with this one" do
+      let(:domain) { create(:domain, server: server) }
+      let(:message) { MessageFactory.outgoing(server, domain: domain) }
+      let(:queued_message) { create(:queued_message, :locked, message: message) }
+      let(:send_result) { Postal::SendResult.new }
+
+      before do
+        smtp_sender_mock = double("SMTPSender")
+        allow(Postal::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)
+      end
+
+      before do
+        # Create 2 extra messages which are similar to the original
+        @message2 = MessageFactory.outgoing(server, domain: domain)
+        @queued_message2 = create(:queued_message, message: @message2)
+        @message3 = MessageFactory.outgoing(server, domain: domain)
+        @queued_message3 = create(:queued_message, message: @message3)
+      end
+
+      it "logs" do
+        service.call
+        expect(logger).to have_logged(/found 2 associated messages/)
+      end
+
+      it "sends processes each message" do
+        allow(service).to receive(:process_message).and_call_original
+        service.call
+        expect(service).to have_received(:process_message).with(queued_message)
+        expect(service).to have_received(:process_message).with(@queued_message2)
+        expect(service).to have_received(:process_message).with(@queued_message3)
+      end
+
+      context "when there is a connect error" do
+        before do
+          send_result.type = "SoftFail"
+          send_result.connect_error = true
+          send_result.details = "Connection Error"
+          send_result.retry = true
+        end
+
+        it "uses the same result for subsequent messages" do
+          service.call
+          expect(Postal::SMTPSender).to have_received(:new).once
+          expect(message.reload.status).to eq "SoftFail"
+          expect(@message2.reload.status).to eq "SoftFail"
+          expect(@message3.reload.status).to eq "SoftFail"
+        end
+      end
+
       context "when the backend message of a sub-message has been removed" do
-        it "removes the queued message for that message"
+        before do
+          @message2.delete
+        end
+
+        it "logs" do
+          service.call
+          expect(logger).to have_logged(/unqueueing because backend message has been removed/)
+        end
+
+        it "removes the queued message for that message" do
+          service.call
+          expect { @queued_message2.reload }.to raise_error(ActiveRecord::RecordNotFound)
+        end
       end
     end
   end