RateLimitedCampaignMailer

Author: tatevikg1

config/services/providers.yml

@@ -6,3 +6,9 @@ services:
   PhpList\Core\Core\ConfigProvider:
     arguments:
       $config: '%app.config%'
+
+  PhpList\Core\Domain\Common\IspRestrictionsProvider:
+    autowire: true
+    autoconfigure: true
+    arguments:
+      $confPath: '%app.phplist_isp_conf_path%'

config/services/services.yml

@@ -52,11 +52,9 @@ services:
     autowire: true
     autoconfigure: true
 
-  PhpList\Core\Domain\Common\IspRestrictionsProvider:
+  PhpList\Core\Domain\Messaging\Service\RateLimitedCampaignMailer:
     autowire: true
     autoconfigure: true
-    arguments:
-      $confPath: '%app.phplist_isp_conf_path%'
 
   PhpList\Core\Domain\Messaging\Service\ConsecutiveBounceHandler:
     autowire: true

src/Domain/Common/IspRestrictionsProvider.php

@@ -12,7 +12,8 @@ class IspRestrictionsProvider
     public function __construct(
         private readonly string $confPath,
         private readonly LoggerInterface $logger,
-    ) {}
+    ) {
+    }
 
     public function load(): IspRestrictions
     {

src/Domain/Common/Model/IspRestrictions.php

@@ -11,8 +11,7 @@ public function __construct(
         public readonly ?int $minBatchPeriod,
         public readonly ?string $lockFile,
         public readonly array $raw = [],
-    )
-    {
+    ) {
     }
 
     public function isEmpty(): bool

src/Domain/Messaging/Service/Processor/CampaignProcessor.php

@@ -8,81 +8,68 @@
 use PhpList\Core\Domain\Messaging\Model\Message;
 use PhpList\Core\Domain\Messaging\Model\UserMessage;
 use PhpList\Core\Domain\Messaging\Model\Message\UserMessageStatus;
+use PhpList\Core\Domain\Messaging\Model\Message\MessageStatus;
 use PhpList\Core\Domain\Messaging\Repository\UserMessageRepository;
+use PhpList\Core\Domain\Messaging\Service\RateLimitedCampaignMailer;
 use PhpList\Core\Domain\Messaging\Service\MessageProcessingPreparator;
-use PhpList\Core\Domain\Messaging\Service\SendRateLimiter;
 use PhpList\Core\Domain\Subscription\Service\Provider\SubscriberProvider;
 use Psr\Log\LoggerInterface;
 use Symfony\Component\Console\Output\OutputInterface;
-use Symfony\Component\Mailer\MailerInterface;
-use Symfony\Component\Mime\Email;
 use Throwable;
 
 class CampaignProcessor
 {
-    private MailerInterface $mailer;
+    private RateLimitedCampaignMailer $mailer;
     private EntityManagerInterface $entityManager;
     private SubscriberProvider $subscriberProvider;
     private MessageProcessingPreparator $messagePreparator;
     private LoggerInterface $logger;
-    private SendRateLimiter $rateLimiter;
     private UserMessageRepository $userMessageRepository;
 
     public function __construct(
-        MailerInterface $mailer,
+        RateLimitedCampaignMailer $mailer,
         EntityManagerInterface $entityManager,
         SubscriberProvider $subscriberProvider,
         MessageProcessingPreparator $messagePreparator,
         LoggerInterface $logger,
-        SendRateLimiter $rateLimiter,
         UserMessageRepository $userMessageRepository
     ) {
         $this->mailer = $mailer;
         $this->entityManager = $entityManager;
         $this->subscriberProvider = $subscriberProvider;
         $this->messagePreparator = $messagePreparator;
         $this->logger = $logger;
-        $this->rateLimiter = $rateLimiter;
         $this->userMessageRepository = $userMessageRepository;
     }
 
     public function process(Message $campaign, ?OutputInterface $output = null): void
     {
-        $this->updateMessageStatus($campaign, Message\MessageStatus::Prepared);
+        $this->updateMessageStatus($campaign, MessageStatus::Prepared);
         $subscribers = $this->subscriberProvider->getSubscribersForMessage($campaign);
 
-        $this->updateMessageStatus($campaign, Message\MessageStatus::InProcess);
+        $this->updateMessageStatus($campaign, MessageStatus::InProcess);
 
         foreach ($subscribers as $subscriber) {
             $existing = $this->userMessageRepository->findOneByUserAndMessage($subscriber, $campaign);
-            if ($existing && $existing->getStatus() !== UserMessageStatus::Todo->value) {
+            if ($existing && $existing->getStatus() !== UserMessageStatus::Todo) {
                 continue;
             }
 
             $userMessage = $existing ?? new UserMessage($subscriber, $campaign);
             $userMessage->setStatus(UserMessageStatus::Active);
             $this->userMessageRepository->save($userMessage);
 
-            $this->rateLimiter->awaitTurn($output);
-
             if (!filter_var($subscriber->getEmail(), FILTER_VALIDATE_EMAIL)) {
                 $this->updateUserMessageStatus($userMessage, UserMessageStatus::InvalidEmailAddress);
                 continue;
             }
 
-            $this->messagePreparator->processMessageLinks($campaign, $subscriber->getId());
-
-            $email = (new Email())
-                ->from('[email protected]')
-                ->to($subscriber->getEmail())
-                ->subject($campaign->getContent()->getSubject())
-                ->text($campaign->getContent()->getTextMessage())
-                ->html($campaign->getContent()->getText());
+            $processed = $this->messagePreparator->processMessageLinks($campaign, $subscriber->getId());
 
             try {
+                $email = $this->mailer->composeEmail($processed, $subscriber);
                 $this->mailer->send($email);
                 $this->updateUserMessageStatus($userMessage, UserMessageStatus::Sent);
-                $this->rateLimiter->afterSend();
             } catch (Throwable $e) {
                 $this->updateUserMessageStatus($userMessage, UserMessageStatus::NotSent);
                 $this->logger->error($e->getMessage(), [
@@ -93,17 +80,18 @@ public function process(Message $campaign, ?OutputInterface $output = null): voi
             }
         }
 
-        $this->updateMessageStatus($campaign, Message\MessageStatus::Sent);
+        $this->updateMessageStatus($campaign, MessageStatus::Sent);
     }
 
-    private function updateMessageStatus(Message $message, Message\MessageStatus $status): void
+    private function updateMessageStatus(Message $message, MessageStatus $status): void
     {
         $message->getMetadata()->setStatus($status);
         $this->entityManager->flush();
     }
 
-    private function updateUserMessageStatus(UserMessage $userMessage, Message\UserMessageStatus $status): void
+    private function updateUserMessageStatus(UserMessage $userMessage, UserMessageStatus $status): void
     {
         $userMessage->setStatus($status);
         $this->entityManager->flush();
-    }}
+    }
+}

src/Domain/Messaging/Service/RateLimitedCampaignMailer.php

@@ -0,0 +1,42 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpList\Core\Domain\Messaging\Service;
+
+use PhpList\Core\Domain\Messaging\Model\Message;
+use PhpList\Core\Domain\Subscription\Model\Subscriber;
+use Symfony\Component\Mailer\Exception\TransportExceptionInterface;
+use Symfony\Component\Mailer\MailerInterface;
+use Symfony\Component\Mime\Email;
+
+class RateLimitedCampaignMailer
+{
+    private MailerInterface $mailer;
+    private SendRateLimiter $limiter;
+    public function __construct(MailerInterface $mailer, SendRateLimiter $limiter)
+    {
+        $this->mailer = $mailer;
+        $this->limiter = $limiter;
+    }
+
+    public function composeEmail(Message $processed, Subscriber $subscriber): Email
+    {
+        return (new Email())
+            ->from('[email protected]')
+            ->to($subscriber->getEmail())
+            ->subject($processed->getContent()->getSubject())
+            ->text($processed->getContent()->getTextMessage())
+            ->html($processed->getContent()->getText());
+    }
+
+    /**
+     * @throws TransportExceptionInterface
+     */
+    public function send(Email $email): void
+    {
+        $this->limiter->awaitTurn();
+        $this->mailer->send($email);
+        $this->limiter->afterSend();
+    }
+}

tests/Unit/Domain/Messaging/Service/Processor/CampaignProcessorTest.php

@@ -12,48 +12,42 @@
 use PhpList\Core\Domain\Messaging\Repository\UserMessageRepository;
 use PhpList\Core\Domain\Messaging\Service\MessageProcessingPreparator;
 use PhpList\Core\Domain\Messaging\Service\Processor\CampaignProcessor;
-use PhpList\Core\Domain\Messaging\Service\SendRateLimiter;
+use PhpList\Core\Domain\Messaging\Service\RateLimitedCampaignMailer;
 use PhpList\Core\Domain\Subscription\Model\Subscriber;
 use PhpList\Core\Domain\Subscription\Service\Provider\SubscriberProvider;
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 use Psr\Log\LoggerInterface;
 use Symfony\Component\Console\Output\OutputInterface;
-use Symfony\Component\Mailer\MailerInterface;
 use Symfony\Component\Mime\Email;
 
 class CampaignProcessorTest extends TestCase
 {
-    private MailerInterface&MockObject $mailer;
-    private EntityManagerInterface&MockObject $entityManager;
-    private SubscriberProvider&MockObject $subscriberProvider;
-    private MessageProcessingPreparator&MockObject $messagePreparator;
-    private LoggerInterface&MockObject $logger;
-    private OutputInterface&MockObject $output;
+    private RateLimitedCampaignMailer|MockObject $mailer;
+    private EntityManagerInterface|MockObject $entityManager;
+    private SubscriberProvider|MockObject $subscriberProvider;
+    private MessageProcessingPreparator|MockObject $messagePreparator;
+    private LoggerInterface|MockObject $logger;
+    private OutputInterface|MockObject $output;
     private CampaignProcessor $campaignProcessor;
-    private SendRateLimiter&MockObject $rateLimiter;
-    private UserMessageRepository&MockObject $userMessageRepository;
+    private UserMessageRepository|MockObject $userMessageRepository;
 
     protected function setUp(): void
     {
-        $this->mailer = $this->createMock(MailerInterface::class);
+        $this->mailer = $this->createMock(RateLimitedCampaignMailer::class);
         $this->entityManager = $this->createMock(EntityManagerInterface::class);
         $this->subscriberProvider = $this->createMock(SubscriberProvider::class);
         $this->messagePreparator = $this->createMock(MessageProcessingPreparator::class);
         $this->logger = $this->createMock(LoggerInterface::class);
         $this->output = $this->createMock(OutputInterface::class);
-        $this->rateLimiter = $this->createMock(SendRateLimiter::class);
         $this->userMessageRepository = $this->createMock(UserMessageRepository::class);
-        $this->rateLimiter->method('awaitTurn');
-        $this->rateLimiter->method('afterSend');
 
         $this->campaignProcessor = new CampaignProcessor(
             mailer: $this->mailer,
             entityManager: $this->entityManager,
             subscriberProvider: $this->subscriberProvider,
             messagePreparator: $this->messagePreparator,
             logger: $this->logger,
-            rateLimiter: $this->rateLimiter,
             userMessageRepository: $this->userMessageRepository,
         );
     }
@@ -131,16 +125,23 @@ public function testProcessWithValidSubscriberEmail(): void
             ->with($campaign, 1)
             ->willReturn($campaign);
 
+        $this->mailer->expects($this->once())
+            ->method('composeEmail')
+            ->with($campaign, $subscriber)
+            ->willReturnCallback(function ($processed, $sub) use ($campaign, $subscriber) {
+                $this->assertSame($campaign, $processed);
+                $this->assertSame($subscriber, $sub);
+                return (new Email())
+                    ->from('[email protected]')
+                    ->to('[email protected]')
+                    ->subject('Test Subject')
+                    ->text('Test text message')
+                    ->html('<p>Test HTML message</p>');
+            });
+
         $this->mailer->expects($this->once())
             ->method('send')
-            ->with($this->callback(function (Email $email) {
-                $this->assertEquals('[email protected]', $email->getTo()[0]->getAddress());
-                $this->assertEquals('[email protected]', $email->getFrom()[0]->getAddress());
-                $this->assertEquals('Test Subject', $email->getSubject());
-                $this->assertEquals('Test text message', $email->getTextBody());
-                $this->assertEquals('<p>Test HTML message</p>', $email->getHtmlBody());
-                return true;
-            }));
+            ->with($this->isInstanceOf(Email::class));
 
         $metadata->expects($this->atLeastOnce())
             ->method('setStatus');
@@ -281,7 +282,7 @@ public function testProcessWithNullOutput(): void
     /**
      * Creates a mock for the Message class with content
      */
-    private function createCampaignMock(): Message&MockObject
+    private function createCampaignMock(): Message|MockObject
     {
         $campaign = $this->createMock(Message::class);
         $content = $this->createMock(MessageContent::class);