MessageQueuerTest::testQueueUpdatedUser() - Code Metrics - Inspection of "Safari 13 cannot request to change password #9775" - Ecodev/artisans - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 6445ca...ccceee )

by Adrien

created 2023-07-18 10:17 UTC

MessageQueuerTest::testQueueUpdatedUser() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	19
Code Lines	11

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	11
nc	1
nop	0
dl	0
loc	19
rs	9.9
c	1
b	0
f	0

<?php

declare(strict_types=1);

namespace ApplicationTest\Service;

use Application\DBAL\Types\MessageTypeType;
use Application\DBAL\Types\PaymentMethodType;
use Application\DBAL\Types\ProductTypeType;
use Application\Model\Country;
use Application\Model\Message;
use Application\Model\Order;
use Application\Model\OrderLine;
use Application\Model\Product;
use Application\Model\Subscription;
use Application\Model\User;
use Application\Service\MessageQueuer;
use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\ORM\EntityManager;
use Ecodev\Felix\Service\MessageRenderer;
use Laminas\View\Renderer\RendererInterface;
use Money\Money;

class MessageQueuerTest extends \PHPUnit\Framework\TestCase
{
    private function createMockMessageQueuer(): MessageQueuer
    {
        global $container;

        $entityManager = $container->get(EntityManager::class);
        $viewRenderer = $container->get(RendererInterface::class);
        $messageRenderer = new MessageRenderer($viewRenderer, 'artisans.lan');
        $config = [
            'email' => [
                'admins' => [
                    '[email protected]',
                    'jane.doe@@example.com',
                ],
            ],
        ];

        $messageQueuer = new MessageQueuer(
            $entityManager,
            $messageRenderer,
            $config,
        );

        return $messageQueuer;
    }

    public function testQueueRegister(): void
    {
        $user = $this->createMockUserMinimal();
        $messageQueuer = $this->createMockMessageQueuer();
        $message = $messageQueuer->queueRegister($user);

        $this->assertMessage($message, $user, '[email protected]', MessageTypeType::REGISTER, 'Demande de création de compte Les artisans de la transition');
    }

    public function testQueueConfirmedRegistration(): void
    {
        $registeredUser = $this->createMockUser();
        $admin = $this->createMockUserAdmin();
        $messageQueuer = $this->createMockMessageQueuer();
        $message = $messageQueuer->queueConfirmedRegistration($admin->getEmail(), $registeredUser);

        $this->assertMessage($message, null, '[email protected]', MessageTypeType::CONFIRMED_REGISTRATION, 'Nouvel utilisateur');
    }

    public function testQueueResetPassword(): void
    {
        $user = $this->createMockUser();
        $messageQueuer = $this->createMockMessageQueuer();
        $message = $messageQueuer->queueResetPassword($user, '[email protected]');

        $this->assertMessage($message, $user, '[email protected]', MessageTypeType::RESET_PASSWORD, 'Demande de modification de mot de passe');
    }

    public function testQueueUpdatedUser(): void
    {
        $updatedUser = $this->createMockUser();
        $admin = $this->createMockUserAdmin();
        $messageQueuer = $this->createMockMessageQueuer();

        $before = [
            'Prénom' => 'John',
            'Nom de famille ' => 'Doe',
        ];

        $after = [
            'Prénom' => 'John',
            'Nom de famille ' => 'Connor',
        ];

        $message = $messageQueuer->queueUpdatedUser($admin->getEmail(), $updatedUser, $before, $after);

        $this->assertMessage($message, null, '[email protected]', MessageTypeType::UPDATED_USER, 'Un utilisateur a modifié ses données personnelles');
    }

    public function testQueueUserPendingOrder(): void
    {
        $user = $this->createMockUser();
        $order = $this->createMockOrder($user);
        $messageQueuer = $this->createMockMessageQueuer();

        $message = $messageQueuer->queueUserPendingOrder($order->getOwner(), $order);

        $this->assertMessage($message, $user, '[email protected]', MessageTypeType::USER_PENDING_ORDER, 'Votre commande est en cours de traitement');
    }

    public function testQueueUserValidatedOrder(): void
    {
        $user = $this->createMockUser();
        $order = $this->createMockOrder($user);
        $messageQueuer = $this->createMockMessageQueuer();

        $message = $messageQueuer->queueUserValidatedOrder($order->getOwner(), $order);

        $this->assertMessage($message, $user, '[email protected]', MessageTypeType::USER_VALIDATED_ORDER, 'Votre commande a été validée');
    }

    public function testQueueAdminPendingOrder(): void
    {
        $admin = $this->createMockUserAdmin();
        $user = $this->createMockUser();
        $order = $this->createMockOrder($user);
        $messageQueuer = $this->createMockMessageQueuer();

        $message = $messageQueuer->queueAdminPendingOrder($admin->getEmail(), $order);

        $this->assertMessage($message, null, '[email protected]', MessageTypeType::ADMIN_PENDING_ORDER, 'Une commande a besoin d\'un BVR');
    }

    public function testQueueAdminPendingOrderWithoutSubscription(): void
    {
        $admin = $this->createMockUserAdmin();
        $user = $this->createMockUser();
        $order = $this->createMockOrder($user, false);
        $messageQueuer = $this->createMockMessageQueuer();

        $message = $messageQueuer->queueAdminPendingOrder($admin->getEmail(), $order);

        $this->assertMessage($message, null, '[email protected]', MessageTypeType::ADMIN_PENDING_ORDER, 'Une commande a besoin d\'un BVR', 'without-subscription');
    }

    public function testQueueAdminValidatedOrder(): void
    {
        $admin = $this->createMockUserAdmin();
        $user = $this->createMockUser();
        $order = $this->createMockOrder($user);
        $messageQueuer = $this->createMockMessageQueuer();

        $message = $messageQueuer->queueAdminValidatedOrder($admin->getEmail(), $order);

        $this->assertMessage($message, null, '[email protected]', MessageTypeType::ADMIN_VALIDATED_ORDER, 'Commande à comptabiliser');
    }

    public function testQueueAdminValidatedOrderWithoutOwner(): void
    {
        $admin = $this->createMockUserAdmin();
        $order = $this->createMockOrder(null);
        $messageQueuer = $this->createMockMessageQueuer();

        $message = $messageQueuer->queueAdminValidatedOrder($admin->getEmail(), $order);

        $this->assertMessage($message, null, '[email protected]', MessageTypeType::ADMIN_VALIDATED_ORDER, 'Commande à comptabiliser', 'without-owner');
    }

    public function testQueueRequestMembershipEnd(): void
    {
        $admin = $this->createMockUserAdmin();
        $user = $this->createMockUser();
        $messageQueuer = $this->createMockMessageQueuer();

        $message = $messageQueuer->queueRequestMembershipEnd($admin->getEmail(), $user);

        $this->assertMessage($message, null, '[email protected]', MessageTypeType::REQUEST_MEMBERSHIP_END, 'Demande d\'arrêt de cotisations');
    }

    public function testQueueNewsletterSubscription(): void
    {
        $admin = $this->createMockUserAdmin();
        $messageQueuer = $this->createMockMessageQueuer();

        $message = $messageQueuer->queueNewsletterSubscription($admin->getEmail(), '[email protected]');

        $this->assertMessage($message, null, '[email protected]', MessageTypeType::NEWSLETTER_SUBSCRIPTION, 'Demande d\'inscription à la newsletter');
    }

    public function testGetEmailsToNotify(): void
    {
        $messageQueuer = $this->createMockMessageQueuer();

        $emails = $messageQueuer->getAllEmailsToNotify();

        self::assertCount(2, $emails);
        self::assertContains('[email protected]', $emails);
    }

    private function createMockOrder(?User $owner, bool $withSubscription = true): Order
    {
        $product = $this->createMock(Product::class);
        $product->expects(self::any())
            ->method('getId')
            ->willReturn(1);

        $product->expects(self::any())
            ->method('getCode')
            ->willReturn('xxx-yyy');

        $product->expects(self::any())
            ->method('getName')
            ->willReturn('Article 1');

        $productLine = new OrderLine();
        $productLine->setProduct($product);
        $productLine->setBalanceCHF(Money::CHF(500));
        $productLine->setBalanceEUR(Money::EUR(0));
        $productLine->setType(ProductTypeType::PAPER);

        $subscriptionLine = new OrderLine();
        $subscriptionLine->setSubscription(new Subscription());
        $subscriptionLine->setName('Abonnement standard papier');
        $subscriptionLine->setBalanceCHF(Money::CHF(1500));
        $subscriptionLine->setBalanceEUR(Money::EUR(0));
        $subscriptionLine->setType(ProductTypeType::BOTH);

        $subscriptionLine2 = new OrderLine();
        $subscriptionLine2->setSubscription(new Subscription());
        $subscriptionLine2->setName('Abonnement institutionnel numérique');
        $subscriptionLine2->setAdditionalEmails(['[email protected]', '[email protected]', '[email protected]']);
        $subscriptionLine2->setBalanceCHF(Money::CHF(2500));
        $subscriptionLine2->setBalanceEUR(Money::EUR(0));
        $subscriptionLine2->setType(ProductTypeType::DIGITAL);

        $donationLine = new OrderLine();
        $donationLine->setName('Don');
        $donationLine->setBalanceCHF(Money::CHF(3500));
        $donationLine->setBalanceEUR(Money::EUR(0));
        $donationLine->setType(ProductTypeType::OTHER);

        if ($withSubscription) {
            $lines = new ArrayCollection([$productLine, $subscriptionLine, $subscriptionLine2, $donationLine]);
        } else {
            $lines = new ArrayCollection([$productLine, $donationLine]);
        }

        $order = $this->createPartialMock(Order::class, ['getId', 'getBalanceCHF', 'getBalanceEUR', 'getOrderLines']);
        $order->setOwner($owner);
        $order->setPaymentMethod(PaymentMethodType::BVR);

        $order->expects(self::any())
            ->method('getId')
            ->willReturn(456);

        $order->expects(self::any())
            ->method('getBalanceCHF')
            ->willReturn(Money::CHF(3300));

        $order->expects(self::any())
            ->method('getBalanceEUR')
            ->willReturn(Money::EUR(0));

        $order->expects(self::any())
            ->method('getOrderLines')
            ->willReturn($lines);

        return $order;
    }

    private function createMockUser(): User
    {
        $user = $this->createMock(User::class);

        $user->expects(self::any())
            ->method('getId')
            ->willReturn(123);

        $user->expects(self::any())
            ->method('getFirstName')
            ->willReturn('John');

        $user->expects(self::any())
            ->method('getLastName')
            ->willReturn('Doe');

        $user->expects(self::any())
            ->method('getName')
            ->willReturn('John Doe');

        $user->expects(self::any())
            ->method('getStreet')
            ->willReturn('Main street');

        $user->expects(self::any())
            ->method('getPostcode')
            ->willReturn('2020');

        $user->expects(self::any())
            ->method('getLocality')
            ->willReturn('Locality');

        $user->expects(self::any())
            ->method('getCountry')
            ->willReturn(new Country('Wookaya'));

        $user->expects(self::any())
            ->method('getPhone')
            ->willReturn('123 456 87 98');

        $user->expects(self::any())
            ->method('getEmail')
            ->willReturn('[email protected]');

        $user->expects(self::any())
            ->method('createToken')
            ->willReturn(str_repeat('X', 32));

        return $user;
    }

    private function createMockUserAdmin(): User
    {
        $user = $this->createMock(User::class);

        $user->expects(self::any())
            ->method('getFirstName')
            ->willReturn('Admin');

        $user->expects(self::any())
            ->method('getLastName')
            ->willReturn('Istrator');

        $user->expects(self::any())
            ->method('getEmail')
            ->willReturn('[email protected]');

        return $user;
    }

    private function createMockUserMinimal(): User
    {
        $user = $this->createMock(User::class);
        $user->expects(self::any())
            ->method('getEmail')
            ->willReturn('[email protected]');

        $user->expects(self::any())
            ->method('createToken')
            ->willReturn(str_repeat('X', 32));

        return $user;
    }

    private function assertMessage(Message $message, ?User $user, string $email, string $type, string $subject, ?string $variant = null): void
    {
        self::assertSame($type, $message->getType());
        self::assertSame($email, $message->getEmail());
        self::assertSame($user, $message->getRecipient());
        self::assertNull($message->getDateSent());
        self::assertSame($subject, $message->getSubject());

        $variant = $variant ? '-' . $variant : $variant;
        $expectedBody = 'tests/data/emails/' . str_replace('_', '-', $type . $variant) . '.html';
        $this->assertFile($expectedBody, $message->getBody());
    }

    /**
     * Custom assert that will not produce gigantic diff.
     */
    private function assertFile(string $file, string $actual): void
    {
        // Log actual result for easier comparison with external diff tools
        $logFile = 'logs/' . $file;
        $dir = dirname($logFile);
        @mkdir($dir, 0o777, true);

        file_put_contents($logFile, $actual);

        self::assertFileExists($file, 'Expected file must exist on disk, fix it with: cp ' . $logFile . ' ' . $file);
        $expected = file_get_contents($file);

        self::assertTrue($expected === $actual, 'File content does not match, compare with: meld ' . $file . ' ' . $logFile);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace ApplicationTest\Service;
6
7			use Application\DBAL\Types\MessageTypeType;
8			use Application\DBAL\Types\PaymentMethodType;
9			use Application\DBAL\Types\ProductTypeType;
10			use Application\Model\Country;
11			use Application\Model\Message;
12			use Application\Model\Order;
13			use Application\Model\OrderLine;
14			use Application\Model\Product;
15			use Application\Model\Subscription;
16			use Application\Model\User;
17			use Application\Service\MessageQueuer;
18			use Doctrine\Common\Collections\ArrayCollection;
19			use Doctrine\ORM\EntityManager;
20			use Ecodev\Felix\Service\MessageRenderer;
21			use Laminas\View\Renderer\RendererInterface;
22			use Money\Money;
23
24			class MessageQueuerTest extends \PHPUnit\Framework\TestCase
25			{
26			private function createMockMessageQueuer(): MessageQueuer
27			{
28			global $container;
29
30			$entityManager = $container->get(EntityManager::class);
31			$viewRenderer = $container->get(RendererInterface::class);
32			$messageRenderer = new MessageRenderer($viewRenderer, 'artisans.lan');
33			$config = [
34			'email' => [
35			'admins' => [
36			'[email protected]',
37			'jane.doe@@example.com',
38			],
39			],
40			];
41
42			$messageQueuer = new MessageQueuer(
43			$entityManager,
44			$messageRenderer,
45			$config,
46			);
47
48			return $messageQueuer;
49			}
50
51			public function testQueueRegister(): void
52			{
53			$user = $this->createMockUserMinimal();
54			$messageQueuer = $this->createMockMessageQueuer();
55			$message = $messageQueuer->queueRegister($user);
56
57			$this->assertMessage($message, $user, '[email protected]', MessageTypeType::REGISTER, 'Demande de création de compte Les artisans de la transition');
58			}
59
60			public function testQueueConfirmedRegistration(): void
61			{
62			$registeredUser = $this->createMockUser();
63			$admin = $this->createMockUserAdmin();
64			$messageQueuer = $this->createMockMessageQueuer();
65			$message = $messageQueuer->queueConfirmedRegistration($admin->getEmail(), $registeredUser);
66
67			$this->assertMessage($message, null, '[email protected]', MessageTypeType::CONFIRMED_REGISTRATION, 'Nouvel utilisateur');
68			}
69
70			public function testQueueResetPassword(): void
71			{
72			$user = $this->createMockUser();
73			$messageQueuer = $this->createMockMessageQueuer();
74			$message = $messageQueuer->queueResetPassword($user, '[email protected]');
75
76			$this->assertMessage($message, $user, '[email protected]', MessageTypeType::RESET_PASSWORD, 'Demande de modification de mot de passe');
77			}
78
79			public function testQueueUpdatedUser(): void
80			{
81			$updatedUser = $this->createMockUser();
82			$admin = $this->createMockUserAdmin();
83			$messageQueuer = $this->createMockMessageQueuer();
84
85			$before = [
86			'Prénom' => 'John',
87			'Nom de famille ' => 'Doe',
88			];
89
90			$after = [
91			'Prénom' => 'John',
92			'Nom de famille ' => 'Connor',
93			];
94
95			$message = $messageQueuer->queueUpdatedUser($admin->getEmail(), $updatedUser, $before, $after);
96
97			$this->assertMessage($message, null, '[email protected]', MessageTypeType::UPDATED_USER, 'Un utilisateur a modifié ses données personnelles');
98			}
99
100			public function testQueueUserPendingOrder(): void
101			{
102			$user = $this->createMockUser();
103			$order = $this->createMockOrder($user);
104			$messageQueuer = $this->createMockMessageQueuer();
105
106			$message = $messageQueuer->queueUserPendingOrder($order->getOwner(), $order);
107
108			$this->assertMessage($message, $user, '[email protected]', MessageTypeType::USER_PENDING_ORDER, 'Votre commande est en cours de traitement');
109			}
110
111			public function testQueueUserValidatedOrder(): void
112			{
113			$user = $this->createMockUser();
114			$order = $this->createMockOrder($user);
115			$messageQueuer = $this->createMockMessageQueuer();
116
117			$message = $messageQueuer->queueUserValidatedOrder($order->getOwner(), $order);
118
119			$this->assertMessage($message, $user, '[email protected]', MessageTypeType::USER_VALIDATED_ORDER, 'Votre commande a été validée');
120			}
121
122			public function testQueueAdminPendingOrder(): void
123			{
124			$admin = $this->createMockUserAdmin();
125			$user = $this->createMockUser();
126			$order = $this->createMockOrder($user);
127			$messageQueuer = $this->createMockMessageQueuer();
128
129			$message = $messageQueuer->queueAdminPendingOrder($admin->getEmail(), $order);
130
131			$this->assertMessage($message, null, '[email protected]', MessageTypeType::ADMIN_PENDING_ORDER, 'Une commande a besoin d\'un BVR');
132			}
133
134			public function testQueueAdminPendingOrderWithoutSubscription(): void
135			{
136			$admin = $this->createMockUserAdmin();
137			$user = $this->createMockUser();
138			$order = $this->createMockOrder($user, false);
139			$messageQueuer = $this->createMockMessageQueuer();
140
141			$message = $messageQueuer->queueAdminPendingOrder($admin->getEmail(), $order);
142
143			$this->assertMessage($message, null, '[email protected]', MessageTypeType::ADMIN_PENDING_ORDER, 'Une commande a besoin d\'un BVR', 'without-subscription');
144			}
145
146			public function testQueueAdminValidatedOrder(): void
147			{
148			$admin = $this->createMockUserAdmin();
149			$user = $this->createMockUser();
150			$order = $this->createMockOrder($user);
151			$messageQueuer = $this->createMockMessageQueuer();
152
153			$message = $messageQueuer->queueAdminValidatedOrder($admin->getEmail(), $order);
154
155			$this->assertMessage($message, null, '[email protected]', MessageTypeType::ADMIN_VALIDATED_ORDER, 'Commande à comptabiliser');
156			}
157
158			public function testQueueAdminValidatedOrderWithoutOwner(): void
159			{
160			$admin = $this->createMockUserAdmin();
161			$order = $this->createMockOrder(null);
162			$messageQueuer = $this->createMockMessageQueuer();
163
164			$message = $messageQueuer->queueAdminValidatedOrder($admin->getEmail(), $order);
165
166			$this->assertMessage($message, null, '[email protected]', MessageTypeType::ADMIN_VALIDATED_ORDER, 'Commande à comptabiliser', 'without-owner');
167			}
168
169			public function testQueueRequestMembershipEnd(): void
170			{
171			$admin = $this->createMockUserAdmin();
172			$user = $this->createMockUser();
173			$messageQueuer = $this->createMockMessageQueuer();
174
175			$message = $messageQueuer->queueRequestMembershipEnd($admin->getEmail(), $user);
176
177			$this->assertMessage($message, null, '[email protected]', MessageTypeType::REQUEST_MEMBERSHIP_END, 'Demande d\'arrêt de cotisations');
178			}
179
180			public function testQueueNewsletterSubscription(): void
181			{
182			$admin = $this->createMockUserAdmin();
183			$messageQueuer = $this->createMockMessageQueuer();
184
185			$message = $messageQueuer->queueNewsletterSubscription($admin->getEmail(), '[email protected]');
186
187			$this->assertMessage($message, null, '[email protected]', MessageTypeType::NEWSLETTER_SUBSCRIPTION, 'Demande d\'inscription à la newsletter');
188			}
189
190			public function testGetEmailsToNotify(): void
191			{
192			$messageQueuer = $this->createMockMessageQueuer();
193
194			$emails = $messageQueuer->getAllEmailsToNotify();
195
196			self::assertCount(2, $emails);
197			self::assertContains('[email protected]', $emails);
198			}
199
200			private function createMockOrder(?User $owner, bool $withSubscription = true): Order
201			{
202			$product = $this->createMock(Product::class);
203			$product->expects(self::any())
204			->method('getId')
205			->willReturn(1);
206
207			$product->expects(self::any())
208			->method('getCode')
209			->willReturn('xxx-yyy');
210
211			$product->expects(self::any())
212			->method('getName')
213			->willReturn('Article 1');
214
215			$productLine = new OrderLine();
216			$productLine->setProduct($product);
217			$productLine->setBalanceCHF(Money::CHF(500));
218			$productLine->setBalanceEUR(Money::EUR(0));
219			$productLine->setType(ProductTypeType::PAPER);
220
221			$subscriptionLine = new OrderLine();
222			$subscriptionLine->setSubscription(new Subscription());
223			$subscriptionLine->setName('Abonnement standard papier');
224			$subscriptionLine->setBalanceCHF(Money::CHF(1500));
225			$subscriptionLine->setBalanceEUR(Money::EUR(0));
226			$subscriptionLine->setType(ProductTypeType::BOTH);
227
228			$subscriptionLine2 = new OrderLine();
229			$subscriptionLine2->setSubscription(new Subscription());
230			$subscriptionLine2->setName('Abonnement institutionnel numérique');
231			$subscriptionLine2->setAdditionalEmails(['[email protected]', '[email protected]', '[email protected]']);
232			$subscriptionLine2->setBalanceCHF(Money::CHF(2500));
233			$subscriptionLine2->setBalanceEUR(Money::EUR(0));
234			$subscriptionLine2->setType(ProductTypeType::DIGITAL);
235
236			$donationLine = new OrderLine();
237			$donationLine->setName('Don');
238			$donationLine->setBalanceCHF(Money::CHF(3500));
239			$donationLine->setBalanceEUR(Money::EUR(0));
240			$donationLine->setType(ProductTypeType::OTHER);
241
242			if ($withSubscription) {
243			$lines = new ArrayCollection([$productLine, $subscriptionLine, $subscriptionLine2, $donationLine]);
244			} else {
245			$lines = new ArrayCollection([$productLine, $donationLine]);
246			}
247
248			$order = $this->createPartialMock(Order::class, ['getId', 'getBalanceCHF', 'getBalanceEUR', 'getOrderLines']);
249			$order->setOwner($owner);
250			$order->setPaymentMethod(PaymentMethodType::BVR);
251
252			$order->expects(self::any())
253			->method('getId')
254			->willReturn(456);
255
256			$order->expects(self::any())
257			->method('getBalanceCHF')
258			->willReturn(Money::CHF(3300));
259
260			$order->expects(self::any())
261			->method('getBalanceEUR')
262			->willReturn(Money::EUR(0));
263
264			$order->expects(self::any())
265			->method('getOrderLines')
266			->willReturn($lines);
267
268			return $order;
269			}
270
271			private function createMockUser(): User
272			{
273			$user = $this->createMock(User::class);
274
275			$user->expects(self::any())
276			->method('getId')
277			->willReturn(123);
278
279			$user->expects(self::any())
280			->method('getFirstName')
281			->willReturn('John');
282
283			$user->expects(self::any())
284			->method('getLastName')
285			->willReturn('Doe');
286
287			$user->expects(self::any())
288			->method('getName')
289			->willReturn('John Doe');
290
291			$user->expects(self::any())
292			->method('getStreet')
293			->willReturn('Main street');
294
295			$user->expects(self::any())
296			->method('getPostcode')
297			->willReturn('2020');
298
299			$user->expects(self::any())
300			->method('getLocality')
301			->willReturn('Locality');
302
303			$user->expects(self::any())
304			->method('getCountry')
305			->willReturn(new Country('Wookaya'));
306
307			$user->expects(self::any())
308			->method('getPhone')
309			->willReturn('123 456 87 98');
310
311			$user->expects(self::any())
312			->method('getEmail')
313			->willReturn('[email protected]');
314
315			$user->expects(self::any())
316			->method('createToken')
317			->willReturn(str_repeat('X', 32));
318
319			return $user;
320			}
321
322			private function createMockUserAdmin(): User
323			{
324			$user = $this->createMock(User::class);
325
326			$user->expects(self::any())
327			->method('getFirstName')
328			->willReturn('Admin');
329
330			$user->expects(self::any())
331			->method('getLastName')
332			->willReturn('Istrator');
333
334			$user->expects(self::any())
335			->method('getEmail')
336			->willReturn('[email protected]');
337
338			return $user;
339			}
340
341			private function createMockUserMinimal(): User
342			{
343			$user = $this->createMock(User::class);
344			$user->expects(self::any())
345			->method('getEmail')
346			->willReturn('[email protected]');
347
348			$user->expects(self::any())
349			->method('createToken')
350			->willReturn(str_repeat('X', 32));
351
352			return $user;
353			}
354
355			private function assertMessage(Message $message, ?User $user, string $email, string $type, string $subject, ?string $variant = null): void
356			{
357			self::assertSame($type, $message->getType());
358			self::assertSame($email, $message->getEmail());
359			self::assertSame($user, $message->getRecipient());
360			self::assertNull($message->getDateSent());
361			self::assertSame($subject, $message->getSubject());
362
363			$variant = $variant ? '-' . $variant : $variant;
364			$expectedBody = 'tests/data/emails/' . str_replace('_', '-', $type . $variant) . '.html';
365			$this->assertFile($expectedBody, $message->getBody());
366			}
367
368			/**
369			* Custom assert that will not produce gigantic diff.
370			*/
371			private function assertFile(string $file, string $actual): void
372			{
373			// Log actual result for easier comparison with external diff tools
374			$logFile = 'logs/' . $file;
375			$dir = dirname($logFile);
376			@mkdir($dir, 0o777, true);
			0 ignored issues – show Bug introduced 2023-07-18 10:47 UTC by Report Bug Copy Issue Report A parse error occurred: Syntax error, unexpected T_STRING, expecting ',' or ')' on line 376 at column 22 Loading history...
377			file_put_contents($logFile, $actual);
378
379			self::assertFileExists($file, 'Expected file must exist on disk, fix it with: cp ' . $logFile . ' ' . $file);
380			$expected = file_get_contents($file);
381
382			self::assertTrue($expected === $actual, 'File content does not match, compare with: meld ' . $file . ' ' . $logFile);
383			}
384			}
385

Ecodev / artisans

Push — master ( 6445ca...ccceee )

MessageQueuerTest::testQueueUpdatedUser() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like