Initial commit: CloudOps infrastructure platform

docker-compose/mautic-setup/mautic-backup-files/docroot/app/bundles/CampaignBundle/Tests/Membership/Action/AdderTest.php

@@ -0,0 +1,110 @@
+<?php
+
+namespace Mautic\CampaignBundle\Tests\Membership\Action;
+
+use Mautic\CampaignBundle\Entity\Campaign;
+use Mautic\CampaignBundle\Entity\Lead as CampaignMember;
+use Mautic\CampaignBundle\Entity\LeadEventLogRepository;
+use Mautic\CampaignBundle\Entity\LeadRepository;
+use Mautic\CampaignBundle\Membership\Action\Adder;
+use Mautic\CampaignBundle\Membership\Exception\ContactCannotBeAddedToCampaignException;
+use Mautic\LeadBundle\Entity\Lead;
+
+class AdderTest extends \PHPUnit\Framework\TestCase
+{
+    /**
+     * @var LeadRepository|\PHPUnit\Framework\MockObject\MockObject
+     */
+    private \PHPUnit\Framework\MockObject\MockObject $leadRepository;
+
+    /**
+     * @var LeadEventLogRepository|\PHPUnit\Framework\MockObject\MockObject
+     */
+    private \PHPUnit\Framework\MockObject\MockObject $leadEventLogRepository;
+
+    protected function setUp(): void
+    {
+        $this->leadRepository         = $this->createMock(LeadRepository::class);
+        $this->leadEventLogRepository = $this->createMock(LeadEventLogRepository::class);
+    }
+
+    public function testNewMemberAdded(): void
+    {
+        $campaign = $this->createMock(Campaign::class);
+        $campaign->method('getId')
+            ->willReturn(1);
+        $campaign->method('allowRestart')
+            ->willReturn(true);
+
+        $contact = $this->createMock(Lead::class);
+        $contact->method('getId')
+            ->WillReturn(2);
+
+        $this->leadEventLogRepository->method('hasBeenInCampaignRotation')
+            ->with(2, 1, 1)
+            ->willReturn(true);
+
+        $this->leadRepository->expects($this->once())
+            ->method('saveEntity');
+
+        $campaignMember = $this->getAdder()->createNewMembership($contact, $campaign, true);
+
+        $this->assertEquals($contact, $campaignMember->getLead());
+        $this->assertEquals($campaign, $campaignMember->getCampaign());
+        $this->assertEquals(true, $campaignMember->wasManuallyAdded());
+        $this->assertEquals(2, $campaignMember->getRotation());
+    }
+
+    public function testManuallyRemovedAddedBackWhenManualActionAddsTheMember(): void
+    {
+        $campaignMember = new CampaignMember();
+        $campaignMember->setManuallyRemoved(true);
+        $campaignMember->setRotation(1);
+        $campaign = new Campaign();
+        $campaign->setAllowRestart(true);
+        $campaignMember->setCampaign($campaign);
+
+        $this->getAdder()->updateExistingMembership($campaignMember, true);
+
+        $this->assertEquals(true, $campaignMember->wasManuallyAdded());
+        $this->assertEquals(2, $campaignMember->getRotation());
+    }
+
+    public function testFilterRemovedAddedBackWhenManualActionAddsTheMember(): void
+    {
+        $campaignMember = new CampaignMember();
+        $campaignMember->setManuallyRemoved(true);
+        $campaignMember->setRotation(1);
+        $campaignMember->setDateLastExited(new \DateTime());
+        $campaign = new Campaign();
+        $campaign->setAllowRestart(true);
+        $campaignMember->setCampaign($campaign);
+
+        $this->getAdder()->updateExistingMembership($campaignMember, false);
+
+        $this->assertEquals(false, $campaignMember->wasManuallyAdded());
+        $this->assertEquals(2, $campaignMember->getRotation());
+    }
+
+    public function testManuallyRemovedIsNotAddedBackWhenFilterActionAddsTheMember(): void
+    {
+        $this->expectException(ContactCannotBeAddedToCampaignException::class);
+
+        $campaignMember = new CampaignMember();
+        $campaignMember->setManuallyRemoved(true);
+        $campaignMember->setRotation(1);
+        $campaign = new Campaign();
+        $campaign->setAllowRestart(false);
+        $campaignMember->setCampaign($campaign);
+
+        $this->getAdder()->updateExistingMembership($campaignMember, false);
+    }
+
+    /**
+     * @return Adder
+     */
+    private function getAdder()
+    {
+        return new Adder($this->leadRepository, $this->leadEventLogRepository);
+    }
+}

docker-compose/mautic-setup/mautic-backup-files/docroot/app/bundles/CampaignBundle/Tests/Membership/Action/RemoverTest.php

@@ -0,0 +1,84 @@
+<?php
+
+namespace Mautic\CampaignBundle\Tests\Membership\Action;
+
+use Mautic\CampaignBundle\Entity\Lead as CampaignMember;
+use Mautic\CampaignBundle\Entity\LeadEventLogRepository;
+use Mautic\CampaignBundle\Entity\LeadRepository;
+use Mautic\CampaignBundle\Membership\Action\Remover;
+use Mautic\CampaignBundle\Membership\Exception\ContactAlreadyRemovedFromCampaignException;
+use Mautic\CoreBundle\Twig\Helper\DateHelper;
+use Symfony\Contracts\Translation\TranslatorInterface;
+
+class RemoverTest extends \PHPUnit\Framework\TestCase
+{
+    /**
+     * @var LeadRepository|\PHPUnit\Framework\MockObject\MockObject
+     */
+    private \PHPUnit\Framework\MockObject\MockObject $leadRepository;
+
+    /**
+     * @var LeadEventLogRepository|\PHPUnit\Framework\MockObject\MockObject
+     */
+    private \PHPUnit\Framework\MockObject\MockObject $leadEventLogRepository;
+
+    protected function setUp(): void
+    {
+        $this->leadRepository         = $this->createMock(LeadRepository::class);
+        $this->leadEventLogRepository = $this->createMock(LeadEventLogRepository::class);
+    }
+
+    public function testMemberHasDateExitedSetWithForcedExit(): void
+    {
+        $campaignMember = new CampaignMember();
+        $campaignMember->setManuallyRemoved(false);
+
+        $this->leadEventLogRepository->expects($this->once())
+            ->method('unscheduleEvents');
+
+        $this->getRemover()->updateExistingMembership($campaignMember, true);
+
+        $this->assertInstanceOf(\DateTime::class, $campaignMember->getDateLastExited());
+    }
+
+    public function testMemberHasDateExistedSetToNullWhenRemovedByFilter(): void
+    {
+        $campaignMember = new CampaignMember();
+        $campaignMember->setManuallyRemoved(false);
+
+        $this->leadEventLogRepository->expects($this->once())
+            ->method('unscheduleEvents');
+
+        $this->getRemover()->updateExistingMembership($campaignMember, false);
+
+        $this->assertNull($campaignMember->getDateLastExited());
+    }
+
+    public function testExceptionThrownWhenMemberIsAlreadyRemoved(): void
+    {
+        $this->expectException(ContactAlreadyRemovedFromCampaignException::class);
+
+        $campaignMember = new CampaignMember();
+        $campaignMember->setManuallyRemoved(true);
+
+        $this->getRemover()->updateExistingMembership($campaignMember, false);
+    }
+
+    /**
+     * @return Remover
+     */
+    private function getRemover()
+    {
+        $translator     = $this->createMock(TranslatorInterface::class);
+        $dateTimeHelper = new DateHelper(
+            'Y-m-d H:i:s',
+            'Y-m-d H:i',
+            'Y-m-d',
+            'H:i',
+            $translator,
+            $this->createMock(\Mautic\CoreBundle\Helper\CoreParametersHelper::class)
+        );
+
+        return new Remover($this->leadRepository, $this->leadEventLogRepository, $translator, $dateTimeHelper);
+    }
+}

docker-compose/mautic-setup/mautic-backup-files/docroot/app/bundles/CampaignBundle/Tests/Membership/EventDispatcherTest.php

@@ -0,0 +1,47 @@
+<?php
+
+namespace Mautic\CampaignBundle\Tests\Membership;
+
+use Mautic\CampaignBundle\CampaignEvents;
+use Mautic\CampaignBundle\Entity\Campaign;
+use Mautic\CampaignBundle\Event\CampaignLeadChangeEvent;
+use Mautic\CampaignBundle\Membership\Action\Adder;
+use Mautic\CampaignBundle\Membership\EventDispatcher;
+use Mautic\LeadBundle\Entity\Lead;
+use Symfony\Component\EventDispatcher\EventDispatcherInterface;
+
+class EventDispatcherTest extends \PHPUnit\Framework\TestCase
+{
+    /**
+     * @var EventDispatcherInterface|\PHPUnit\Framework\MockObject\MockObject
+     */
+    private \PHPUnit\Framework\MockObject\MockObject $eventDispatcher;
+
+    protected function setUp(): void
+    {
+        $this->eventDispatcher = $this->createMock(EventDispatcherInterface::class);
+    }
+
+    public function testLeadChangeEventDispatched(): void
+    {
+        $this->eventDispatcher->expects($this->once())
+            ->method('dispatch')
+            ->with($this->isInstanceOf(CampaignLeadChangeEvent::class), CampaignEvents::CAMPAIGN_ON_LEADCHANGE);
+
+        $this->getDispatcher()->dispatchMembershipChange(new Lead(), new Campaign(), Adder::NAME);
+    }
+
+    public function testBatchChangeEventDispatched(): void
+    {
+        $this->eventDispatcher->expects($this->once())
+            ->method('dispatch')
+            ->with($this->isInstanceOf(CampaignLeadChangeEvent::class), CampaignEvents::LEAD_CAMPAIGN_BATCH_CHANGE);
+
+        $this->getDispatcher()->dispatchBatchMembershipChange([new Lead()], new Campaign(), Adder::NAME);
+    }
+
+    private function getDispatcher()
+    {
+        return new EventDispatcher($this->eventDispatcher);
+    }
+}

docker-compose/mautic-setup/mautic-backup-files/docroot/app/bundles/CampaignBundle/Tests/Membership/MembershipBuilderTest.php

@@ -0,0 +1,220 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Mautic\CampaignBundle\Tests\Membership;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Mautic\CampaignBundle\Entity\Campaign;
+use Mautic\CampaignBundle\Entity\LeadRepository as CampaignMemberRepository;
+use Mautic\CampaignBundle\Executioner\ContactFinder\Limiter\ContactLimiter;
+use Mautic\CampaignBundle\Membership\MembershipBuilder;
+use Mautic\CampaignBundle\Membership\MembershipManager;
+use Mautic\LeadBundle\Entity\Lead;
+use Mautic\LeadBundle\Entity\LeadRepository;
+use PHPUnit\Framework\MockObject\MockObject;
+use Symfony\Contracts\Translation\TranslatorInterface;
+
+final class MembershipBuilderTest extends \PHPUnit\Framework\TestCase
+{
+    /**
+     * @var MembershipManager|MockObject
+     */
+    private MockObject $manager;
+
+    /**
+     * @var CampaignMemberRepository|MockObject
+     */
+    private MockObject $campaignMemberRepository;
+
+    /**
+     * @var LeadRepository|MockObject
+     */
+    private MockObject $leadRepository;
+
+    /**
+     * @var TranslatorInterface|MockObject
+     */
+    private MockObject $translator;
+
+    private MembershipBuilder $membershipBuilder;
+
+    protected function setUp(): void
+    {
+        $this->manager                  = $this->createMock(MembershipManager::class);
+        $this->campaignMemberRepository = $this->createMock(CampaignMemberRepository::class);
+        $this->leadRepository           = $this->createMock(LeadRepository::class);
+        $this->translator               = $this->createMock(TranslatorInterface::class);
+        $this->membershipBuilder        = new MembershipBuilder(
+            $this->manager,
+            $this->campaignMemberRepository,
+            $this->leadRepository,
+            $this->translator
+        );
+    }
+
+    public function testContactCountIsSkippedWhenOutputIsNull(): void
+    {
+        $campaign       = new Campaign();
+        $contactLimiter = new ContactLimiter(100);
+
+        $this->campaignMemberRepository->expects($this->never())
+            ->method('getCountsForCampaignContactsBySegment');
+
+        $this->campaignMemberRepository->expects($this->never())
+            ->method('getCountsForOrphanedContactsBySegments');
+
+        $this->campaignMemberRepository->expects($this->once())
+            ->method('getCampaignContactsBySegments')
+            ->willReturn([]);
+
+        $this->campaignMemberRepository->expects($this->once())
+            ->method('getOrphanedContacts')
+            ->willReturn([]);
+
+        $this->membershipBuilder->build($campaign, $contactLimiter, 1000);
+    }
+
+    public function testContactsAreNotRemovedIfRunLimitReachedWhileAdding(): void
+    {
+        $campaign       = new Campaign();
+        $contactLimiter = new ContactLimiter(100);
+
+        $this->campaignMemberRepository->expects($this->once())
+            ->method('getCampaignContactsBySegments')
+            ->willReturn([20, 21, 22]);
+
+        $this->leadRepository->expects($this->once())
+            ->method('getContactCollection')
+            ->willReturn(new ArrayCollection([new Lead(), new Lead(), new Lead()]));
+
+        $this->campaignMemberRepository->expects($this->never())
+            ->method('getOrphanedContacts');
+
+        $this->membershipBuilder->build($campaign, $contactLimiter, 2);
+    }
+
+    public function testWhileLoopBreaksWithNoMoreContacts(): void
+    {
+        $campaign = new class extends Campaign {
+            public function getId(): int
+            {
+                return 111;
+            }
+        };
+
+        $contactLimiter = new ContactLimiter(1);
+        $matcher        = $this->exactly(4);
+
+        $this->campaignMemberRepository->expects($matcher)
+            ->method('getCampaignContactsBySegments')->willReturnCallback(function (...$parameters) use ($matcher, $contactLimiter) {
+                if (1 === $matcher->numberOfInvocations()) {
+                    $this->assertSame(111, $parameters[0]);
+                    $this->assertSame($contactLimiter, $parameters[1]);
+                    $this->assertFalse($parameters[2]);
+
+                    return [20];
+                }
+                if (2 === $matcher->numberOfInvocations()) {
+                    $this->assertSame(111, $parameters[0]);
+                    $this->assertSame($contactLimiter, $parameters[1]);
+                    $this->assertFalse($parameters[2]);
+
+                    return [21];
+                }
+                if (3 === $matcher->numberOfInvocations()) {
+                    $this->assertSame(111, $parameters[0]);
+                    $this->assertSame($contactLimiter, $parameters[1]);
+                    $this->assertFalse($parameters[2]);
+
+                    return [22];
+                }
+                if (4 === $matcher->numberOfInvocations()) {
+                    $this->assertSame(111, $parameters[0]);
+                    $this->assertSame($contactLimiter, $parameters[1]);
+                    $this->assertFalse($parameters[2]);
+
+                    return [];
+                }
+            });
+
+        $this->manager->expects($this->exactly(3))
+            ->method('addContacts');
+
+        $this->campaignMemberRepository->expects($this->exactly(4))
+            ->method('getOrphanedContacts')
+            ->willReturnOnConsecutiveCalls([23], [24], [25], []);
+
+        $this->manager->expects($this->exactly(3))
+            ->method('removeContacts');
+
+        $this->leadRepository->expects($this->exactly(6))
+            ->method('getContactCollection')
+            ->willReturn(new ArrayCollection([new Lead()]));
+
+        $this->membershipBuilder->build($campaign, $contactLimiter, 100);
+    }
+
+    public function testWhileLoopBreaksWithNoMoreContactsForRepeatableCampaign(): void
+    {
+        $campaign = new class extends Campaign {
+            public function getId(): int
+            {
+                return 111;
+            }
+        };
+
+        $campaign->setAllowRestart(true);
+
+        $contactLimiter = new ContactLimiter(1);
+        $matcher        = $this->exactly(4);
+
+        $this->campaignMemberRepository->expects($matcher)
+            ->method('getCampaignContactsBySegments')->willReturnCallback(function (...$parameters) use ($matcher, $contactLimiter) {
+                if (1 === $matcher->numberOfInvocations()) {
+                    $this->assertSame(111, $parameters[0]);
+                    $this->assertSame($contactLimiter, $parameters[1]);
+                    $this->assertTrue($parameters[2]);
+
+                    return [20];
+                }
+                if (2 === $matcher->numberOfInvocations()) {
+                    $this->assertSame(111, $parameters[0]);
+                    $this->assertSame($contactLimiter, $parameters[1]);
+                    $this->assertTrue($parameters[2]);
+
+                    return [21];
+                }
+                if (3 === $matcher->numberOfInvocations()) {
+                    $this->assertSame(111, $parameters[0]);
+                    $this->assertSame($contactLimiter, $parameters[1]);
+                    $this->assertTrue($parameters[2]);
+
+                    return [22];
+                }
+                if (4 === $matcher->numberOfInvocations()) {
+                    $this->assertSame(111, $parameters[0]);
+                    $this->assertSame($contactLimiter, $parameters[1]);
+                    $this->assertTrue($parameters[2]);
+
+                    return [];
+                }
+            });
+
+        $this->manager->expects($this->exactly(3))
+            ->method('addContacts');
+
+        $this->campaignMemberRepository->expects($this->exactly(4))
+            ->method('getOrphanedContacts')
+            ->willReturnOnConsecutiveCalls([23], [24], [25], []);
+
+        $this->manager->expects($this->exactly(3))
+            ->method('removeContacts');
+
+        $this->leadRepository->expects($this->exactly(6))
+            ->method('getContactCollection')
+            ->willReturn(new ArrayCollection([new Lead()]));
+
+        $this->membershipBuilder->build($campaign, $contactLimiter, 100);
+    }
+}

docker-compose/mautic-setup/mautic-backup-files/docroot/app/bundles/CampaignBundle/Tests/Membership/MembershipManagerTest.php

@@ -0,0 +1,177 @@
+<?php
+
+namespace Mautic\CampaignBundle\Tests\Membership;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use Mautic\CampaignBundle\Entity\Campaign;
+use Mautic\CampaignBundle\Entity\Lead as CampaignMember;
+use Mautic\CampaignBundle\Entity\LeadRepository;
+use Mautic\CampaignBundle\Membership\Action\Adder;
+use Mautic\CampaignBundle\Membership\Action\Remover;
+use Mautic\CampaignBundle\Membership\EventDispatcher;
+use Mautic\CampaignBundle\Membership\MembershipManager;
+use Mautic\LeadBundle\Entity\Lead;
+use Psr\Log\NullLogger;
+
+class MembershipManagerTest extends \PHPUnit\Framework\TestCase
+{
+    /**
+     * @var Adder|\PHPUnit\Framework\MockObject\MockObject
+     */
+    private \PHPUnit\Framework\MockObject\MockObject $adder;
+
+    /**
+     * @var Remover|\PHPUnit\Framework\MockObject\MockObject
+     */
+    private \PHPUnit\Framework\MockObject\MockObject $remover;
+
+    /**
+     * @var EventDispatcher|\PHPUnit\Framework\MockObject\MockObject
+     */
+    private \PHPUnit\Framework\MockObject\MockObject $eventDispatcher;
+
+    /**
+     * @var LeadRepository|\PHPUnit\Framework\MockObject\MockObject
+     */
+    private \PHPUnit\Framework\MockObject\MockObject $leadRepository;
+
+    private NullLogger $logger;
+
+    protected function setUp(): void
+    {
+        $this->adder           = $this->createMock(Adder::class);
+        $this->remover         = $this->createMock(Remover::class);
+        $this->eventDispatcher = $this->createMock(EventDispatcher::class);
+        $this->leadRepository  = $this->createMock(LeadRepository::class);
+        $this->logger          = new NullLogger();
+    }
+
+    public function testMembershipCreatedIfNotFound(): void
+    {
+        $contact  = new Lead();
+        $campaign = new Campaign();
+
+        $this->leadRepository->expects($this->once())
+            ->method('findOneBy')
+            ->willReturn(null);
+
+        $this->adder->expects($this->once())
+            ->method('createNewMembership');
+
+        $this->eventDispatcher->expects($this->once())
+            ->method('dispatchMembershipChange');
+
+        $this->getManager()->addContact($contact, $campaign);
+    }
+
+    public function testMembershipUpdatedIfFound(): void
+    {
+        $contact        = new Lead();
+        $campaign       = new Campaign();
+        $campaignMember = new CampaignMember();
+        $campaignMember->setLead($contact);
+        $campaignMember->setCampaign($campaign);
+
+        $this->leadRepository->expects($this->once())
+            ->method('findOneBy')
+            ->willReturn($campaignMember);
+
+        $this->adder->expects($this->once())
+            ->method('updateExistingMembership');
+
+        $this->eventDispatcher->expects($this->once())
+            ->method('dispatchMembershipChange');
+
+        $this->getManager()->addContact($contact, $campaign);
+    }
+
+    public function testMembershipIsUpdatedWhenRemoved(): void
+    {
+        $contact        = new Lead();
+        $campaign       = new Campaign();
+        $campaignMember = new CampaignMember();
+        $campaignMember->setLead($contact);
+        $campaignMember->setCampaign($campaign);
+
+        $this->leadRepository->expects($this->once())
+            ->method('findOneBy')
+            ->willReturn($campaignMember);
+
+        $this->remover->expects($this->once())
+            ->method('updateExistingMembership');
+
+        $this->eventDispatcher->expects($this->once())
+            ->method('dispatchMembershipChange');
+
+        $this->getManager()->removeContact($contact, $campaign);
+    }
+
+    public function testContactsAreAddedOrUpdated(): void
+    {
+        $contact = $this->createMock(Lead::class);
+        $contact->method('getId')
+            ->willReturn(1);
+        $contact2 = $this->createMock(Lead::class);
+        $contact2->method('getId')
+            ->willReturn(2);
+
+        $campaign       = new Campaign();
+        $campaignMember = new CampaignMember();
+        $campaignMember->setLead($contact2);
+        $campaignMember->setCampaign($campaign);
+
+        // One is found and one is not
+        $this->leadRepository->expects($this->once())
+            ->method('getCampaignMembers')
+            ->willReturn([$contact2->getId() => $campaignMember]);
+
+        $this->adder->expects($this->once())
+            ->method('updateExistingMembership')
+            ->with($campaignMember, true);
+
+        $this->adder->expects($this->once())
+            ->method('createNewMembership')
+            ->with($contact, $campaign, true);
+
+        $this->eventDispatcher->expects($this->once())
+            ->method('dispatchBatchMembershipChange')
+            ->with([$contact->getId() => $contact, $contact2->getId() => $contact2], $campaign, Adder::NAME);
+
+        $this->getManager()->addContacts(new ArrayCollection([1 => $contact, 2 => $contact2]), $campaign);
+    }
+
+    public function testContactsAreRemoved(): void
+    {
+        $contact = $this->createMock(Lead::class);
+        $contact->method('getId')
+            ->willReturn(1);
+        $contact2 = $this->createMock(Lead::class);
+        $contact2->method('getId')
+            ->willReturn(2);
+
+        $campaign       = new Campaign();
+        $campaignMember = new CampaignMember();
+        $campaignMember->setLead($contact2);
+        $campaignMember->setCampaign($campaign);
+
+        // One is found and one is not
+        $this->leadRepository->expects($this->once())
+            ->method('getCampaignMembers')
+            ->willReturn([$contact2->getId() => $campaignMember]);
+
+        $this->remover->expects($this->once())
+            ->method('updateExistingMembership')
+            ->with($campaignMember, false);
+
+        $this->eventDispatcher->expects($this->once())
+            ->method('dispatchBatchMembershipChange')
+            ->with([$contact2->getId() => $contact2], $campaign, Remover::NAME);
+
+        $this->getManager()->removeContacts(new ArrayCollection([1 => $contact, 2 => $contact2]), $campaign);
+    }
+
+    private function getManager()
+    {
+        return new MembershipManager($this->adder, $this->remover, $this->eventDispatcher, $this->leadRepository, $this->logger);
+    }
+}