Fix tests

Author: tatevikg1

src/Domain/Messaging/Service/MessageProcessingPreparator.php

@@ -4,7 +4,6 @@
 
 namespace PhpList\Core\Domain\Messaging\Service;
 
-use Doctrine\ORM\EntityManagerInterface;
 use PhpList\Core\Domain\Analytics\Service\LinkTrackService;
 use PhpList\Core\Domain\Messaging\Model\Message;
 use PhpList\Core\Domain\Messaging\Repository\MessageRepository;
@@ -17,20 +16,17 @@ class MessageProcessingPreparator
     // phpcs:ignore Generic.Commenting.Todo
     // @todo: create functionality to track
     public const LINT_TRACK_ENDPOINT = '/api/v2/link-track';
-    private EntityManagerInterface $entityManager;
     private SubscriberRepository $subscriberRepository;
     private MessageRepository $messageRepository;
     private LinkTrackService $linkTrackService;
     private TranslatorInterface $translator;
 
     public function __construct(
-        EntityManagerInterface $entityManager,
         SubscriberRepository $subscriberRepository,
         MessageRepository $messageRepository,
         LinkTrackService $linkTrackService,
         TranslatorInterface $translator,
     ) {
-        $this->entityManager = $entityManager;
         $this->subscriberRepository = $subscriberRepository;
         $this->messageRepository = $messageRepository;
         $this->linkTrackService = $linkTrackService;

tests/Unit/Domain/Analytics/Service/LinkTrackServiceTest.php

@@ -42,7 +42,7 @@ public function testExtractAndSaveLinksWithNoLinks(): void
         $message->method('getId')->willReturn($messageId);
         $message->method('getContent')->willReturn($messageContent);
 
-        $this->linkTrackRepository->expects(self::never())->method('save');
+        $this->linkTrackRepository->expects(self::never())->method('persist');
 
         $result = $this->subject->extractAndSaveLinks($message, $userId);
 
@@ -63,7 +63,7 @@ public function testExtractAndSaveLinksWithLinks(): void
         $message->method('getContent')->willReturn($messageContent);
 
         $this->linkTrackRepository->expects(self::exactly(2))
-            ->method('save')
+            ->method('persist')
             ->willReturnCallback(function (LinkTrack $linkTrack) use ($messageId, $userId) {
                 self::assertSame($messageId, $linkTrack->getMessageId());
                 self::assertSame($userId, $linkTrack->getUserId());
@@ -92,7 +92,7 @@ public function testExtractAndSaveLinksWithFooter(): void
         $message->method('getContent')->willReturn($messageContent);
 
         $this->linkTrackRepository->expects(self::exactly(2))
-            ->method('save')
+            ->method('persist')
             ->willReturnCallback(function (LinkTrack $linkTrack) use ($messageId, $userId) {
                 self::assertSame($messageId, $linkTrack->getMessageId());
                 self::assertSame($userId, $linkTrack->getUserId());
@@ -120,7 +120,7 @@ public function testExtractAndSaveLinksWithDuplicateLinks(): void
         $message->method('getContent')->willReturn($messageContent);
 
         $this->linkTrackRepository->expects(self::once())
-            ->method('save')
+            ->method('persist')
             ->willReturnCallback(function (LinkTrack $linkTrack) use ($messageId, $userId) {
                 self::assertSame($messageId, $linkTrack->getMessageId());
                 self::assertSame($userId, $linkTrack->getUserId());
@@ -147,7 +147,7 @@ public function testExtractAndSaveLinksWithNullText(): void
         $message->method('getContent')->willReturn($messageContent);
 
         $this->linkTrackRepository->expects(self::once())
-            ->method('save')
+            ->method('persist')
             ->willReturnCallback(function (LinkTrack $linkTrack) use ($messageId, $userId) {
                 self::assertSame($messageId, $linkTrack->getMessageId());
                 self::assertSame($userId, $linkTrack->getUserId());
@@ -219,7 +219,7 @@ public function testExtractAndSaveLinksWithExistingLink(): void
             ->willReturn($existingLinkTrack);
 
         $this->linkTrackRepository->expects(self::never())
-            ->method('save');
+            ->method('persist');
 
         $result = $this->subject->extractAndSaveLinks($message, $userId);
 

tests/Unit/Domain/Messaging/Command/ProcessQueueCommandTest.php

@@ -4,26 +4,29 @@
 
 namespace PhpList\Core\Tests\Unit\Domain\Messaging\Command;
 
+use Doctrine\ORM\EntityManagerInterface;
 use Exception;
 use PhpList\Core\Domain\Configuration\Service\Provider\ConfigProvider;
 use PhpList\Core\Domain\Messaging\Command\ProcessQueueCommand;
+use PhpList\Core\Domain\Messaging\Message\CampaignProcessorMessage;
 use PhpList\Core\Domain\Messaging\Model\Message;
 use PhpList\Core\Domain\Messaging\Repository\MessageRepository;
 use PhpList\Core\Domain\Messaging\Service\MessageProcessingPreparator;
-use PhpList\Core\Domain\Messaging\Service\Processor\CampaignProcessor;
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Console\Application;
 use Symfony\Component\Console\Tester\CommandTester;
 use Symfony\Component\Lock\LockFactory;
 use Symfony\Component\Lock\LockInterface;
+use Symfony\Component\Messenger\Envelope;
+use Symfony\Component\Messenger\MessageBusInterface;
 use Symfony\Component\Translation\Translator;
 
 class ProcessQueueCommandTest extends TestCase
 {
     private MessageRepository&MockObject $messageRepository;
     private MessageProcessingPreparator&MockObject $messageProcessingPreparator;
-    private CampaignProcessor&MockObject $campaignProcessor;
+    private MessageBusInterface&MockObject $messageBus;
     private LockInterface&MockObject $lock;
     private CommandTester $commandTester;
     private Translator&MockObject $translator;
@@ -33,7 +36,7 @@ protected function setUp(): void
         $this->messageRepository = $this->createMock(MessageRepository::class);
         $lockFactory = $this->createMock(LockFactory::class);
         $this->messageProcessingPreparator = $this->createMock(MessageProcessingPreparator::class);
-        $this->campaignProcessor = $this->createMock(CampaignProcessor::class);
+        $this->messageBus = $this->createMock(MessageBusInterface::class);
         $this->lock = $this->createMock(LockInterface::class);
         $this->translator = $this->createMock(Translator::class);
 
@@ -45,9 +48,10 @@ protected function setUp(): void
             messageRepository: $this->messageRepository,
             lockFactory: $lockFactory,
             messagePreparator: $this->messageProcessingPreparator,
-            campaignProcessor: $this->campaignProcessor,
+            messageBus: $this->messageBus,
             configProvider: $this->createMock(ConfigProvider::class),
             translator: $this->translator,
+            entityManager: $this->createMock(EntityManagerInterface::class),
         );
 
         $application = new Application();
@@ -97,8 +101,8 @@ public function testExecuteWithNoCampaigns(): void
             ->with($this->anything(), $this->anything())
             ->willReturn([]);
 
-        $this->campaignProcessor->expects($this->never())
-            ->method('process');
+        $this->messageBus->expects($this->never())
+            ->method('dispatch');
 
         $this->commandTester->execute([]);
 
@@ -121,22 +125,29 @@ public function testExecuteWithCampaigns(): void
             ->method('ensureCampaignsHaveUuid');
 
         $campaign = $this->createMock(Message::class);
+        $campaign->method('getId')->willReturn(1);
 
         $this->messageRepository->expects($this->once())
             ->method('getByStatusAndEmbargo')
             ->with($this->anything(), $this->anything())
             ->willReturn([$campaign]);
 
-        $this->campaignProcessor->expects($this->once())
-            ->method('process')
-            ->with($campaign, $this->anything());
+        $this->messageBus->expects($this->once())
+            ->method('dispatch')
+            ->with(
+                $this->callback(function (CampaignProcessorMessage $message) use ($campaign) {
+                    $this->assertEquals($campaign->getId(), $message->getMessageId());
+                    return true;
+                }),
+                $this->equalTo([])
+            )
+            ->willReturn(new Envelope(new CampaignProcessorMessage($campaign->getId())));
 
         $this->commandTester->execute([]);
 
         $this->assertEquals(0, $this->commandTester->getStatusCode());
     }
 
-
     public function testExecuteWithMultipleCampaigns(): void
     {
         $this->lock->expects($this->once())
@@ -153,26 +164,36 @@ public function testExecuteWithMultipleCampaigns(): void
             ->method('ensureCampaignsHaveUuid');
 
         $campaign1 = $this->createMock(Message::class);
+        $campaign1->method('getId')->willReturn(1);
         $campaign2 = $this->createMock(Message::class);
+        $campaign2->method('getId')->willReturn(2);
 
         $this->messageRepository->expects($this->once())
             ->method('getByStatusAndEmbargo')
             ->with($this->anything(), $this->anything())
             ->willReturn([$campaign1, $campaign2]);
 
-        $this->campaignProcessor->expects($this->exactly(2))
-            ->method('process')
-            ->withConsecutive(
-                [$campaign1, $this->anything()],
-                [$campaign2, $this->anything()]
-            );
+        $this->messageBus->expects($this->exactly(2))
+            ->method('dispatch')
+            ->willReturnCallback(function (CampaignProcessorMessage $message, array $stamps) use ($campaign1, $campaign2) {
+                static $call = 0;
+                $call++;
+                if ($call === 1) {
+                    $this->assertEquals($campaign1->getId(), $message->getMessageId());
+                } else {
+                    $this->assertEquals($campaign2->getId(), $message->getMessageId());
+                }
+                $this->assertSame([], $stamps);
+
+                return new Envelope(new CampaignProcessorMessage($message->getMessageId()));
+            });
 
         $this->commandTester->execute([]);
 
         $this->assertEquals(0, $this->commandTester->getStatusCode());
     }
 
-    public function testExecuteWithProcessorException(): void
+    public function testExecuteWithDispatcherException(): void
     {
         $this->lock->expects($this->once())
             ->method('acquire')
@@ -188,16 +209,23 @@ public function testExecuteWithProcessorException(): void
             ->method('ensureCampaignsHaveUuid');
 
         $campaign = $this->createMock(Message::class);
+        $campaign->method('getId')->willReturn(1);
 
         $this->messageRepository->expects($this->once())
             ->method('getByStatusAndEmbargo')
             ->with($this->anything(), $this->anything())
             ->willReturn([$campaign]);
 
-        $this->campaignProcessor->expects($this->once())
-            ->method('process')
-            ->with($campaign, $this->anything())
-            ->willThrowException(new Exception('Test exception'));
+        $this->messageBus->expects($this->once())
+            ->method('dispatch')
+            ->with(
+                $this->callback(function (CampaignProcessorMessage $message) use ($campaign) {
+                    $this->assertEquals($campaign->getId(), $message->getMessageId());
+                    return true;
+                }),
+                $this->equalTo([])
+            )
+            ->willThrowException(new Exception());
 
         $this->commandTester->execute([]);