badams / symfony-mailer-amazon-sdk

tests/SesSdkTransportFactoryTest.php

<?php

/*
 * This file is part of the badams/symfony-amazon-sdk-mailer package.
 *
 * (c) Byron Adams <byron.adams54@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

use Aws\Credentials\Credentials;
use Badams\AmazonMailerSdk\SesSdkTransport;
use Badams\AmazonMailerSdk\SesSdkTransportFactory;
use GuzzleHttp\Promise\Promise;
use PHPUnit\Framework\TestCase;
use Psr\Log\LoggerInterface;
use Symfony\Component\Mailer\Exception\UnsupportedSchemeException;
use Symfony\Component\Mailer\Transport\Dsn;
use Symfony\Component\Mailer\Transport\TransportFactoryInterface;
use Symfony\Component\Mailer\Transport\TransportInterface;
use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
use Symfony\Contracts\HttpClient\HttpClientInterface;

class SesSdkTransportFactoryTest extends TestCase
{
    protected const USER = 'USER';
    protected const PASSWORD = 'PASS';
    protected const ENV_USER = 'ENV_USER';
    protected const ENV_PASSWORD = 'ENV_PASS';
    protected const INSTANCE_USER = 'INSTANCE_USER';
    protected const INSTANCE_PASSWORD = 'INSTANCE_PASS';
    protected const ECS_USER = 'ECS_USER';
    protected const ECS_PASSWORD = 'ECS_USER';
    protected const DEFAULT_USER = 'DEFAULT_USER';
    protected const DEFAULT_PASSWORD = 'DEFAULT_PASS';

    public function getFactory(): TransportFactoryInterface
    {
        return new SesSdkTransportFactory($this->getDispatcher(), $this->getClient(), $this->getLogger());
    }

    /**
     * @dataProvider createProvider
     * @param Dsn $dsn
     * @param TransportInterface $transport
     */
    public function testCreate(Dsn $dsn, TransportInterface $transport): void
    {
        $credentialsProviderMock = \Mockery::mock('overload:\Aws\Credentials\CredentialProvider');
        $credentialsProviderMock->allows([
            'fromCredentials' => $this->createCredentialsResolver(self::USER, self::PASSWORD),
            'env' => $this->createCredentialsResolver(self::ENV_USER, self::ENV_PASSWORD),
            'instanceProfile' => $this->createCredentialsResolver(self::INSTANCE_USER, self::INSTANCE_PASSWORD),
            'ecsCredentials' => $this->createCredentialsResolver(self::ECS_USER, self::ECS_PASSWORD),
            'defaultProvider' => $this->createCredentialsResolver(self::DEFAULT_USER, self::DEFAULT_PASSWORD),
        ]);

        $factory = $this->getFactory();
        $instance = $factory->create($dsn);
        $this->assertEquals($transport, $instance);
        $this->assertEquals((string)$transport, (string)$instance);
        $this->assertStringMatchesFormat($dsn->getScheme() . '://%S' . $dsn->getHost() . '%S', (string)$transport);

        \Mockery::close();
    }


    /**
     * @dataProvider supportsProvider
     */
    public function testSupports(Dsn $dsn, bool $supports): void
    {
        $factory = $this->getFactory();

        $this->assertSame($supports, $factory->supports($dsn));
    }

    /**
     * @dataProvider unsupportedSchemeProvider
     */
    public function testUnsupportedSchemeException(Dsn $dsn, string $message = null): void
    {
        $factory = $this->getFactory();

        $this->expectException(UnsupportedSchemeException::class);
        if (null !== $message) {
            $this->expectExceptionMessage($message);
        }

        $factory->create($dsn);
    }


    public function supportsProvider(): iterable
    {
        yield [
            new Dsn('ses+sdk', 'default'),
            true,
        ];

        yield [
            new Dsn('ses+https', 'default'),
            false,
        ];

        yield [
            new Dsn('ses+api', 'default'),
            false,
        ];

        yield [
            new Dsn('ses+smtp', 'default'),
            false,
        ];
    }

    public function createProvider(): iterable
    {
        $dispatcher = $this->getDispatcher();
        $logger = $this->getLogger();

        yield [
            new Dsn('ses+sdk', 'us-west-1', self::USER, self::PASSWORD),
            new SesSdkTransport(
                $this->createConfig(self::USER, self::PASSWORD,'us-west-1'),
                $dispatcher,
                $logger
            ),
        ];

        yield [
            new Dsn('ses+sdk', 'ap-south-2', null, null, null, [
                'credentials' => 'env',
            ]),
            new SesSdkTransport(
                $this->createConfig(self::ENV_USER, self::ENV_PASSWORD, 'ap-south-2'),
                $dispatcher,
                $logger
            ),
        ];

        yield [
            new Dsn('ses+sdk', 'ap-south-2', null, null, null, [
                'credentials' => 'instance',
            ]),
            new SesSdkTransport(
                $this->createConfig(self::INSTANCE_USER, self::INSTANCE_PASSWORD, 'ap-south-2'),
                $dispatcher,
                $logger
            ),
        ];

        yield [
            new Dsn('ses+sdk', 'eu-west-1', null, null, null, ['credentials' => 'ecs']),
            new SesSdkTransport(
                $this->createConfig(self::ECS_USER, self::ECS_PASSWORD,'eu-west-1'),
                $dispatcher,
                $logger
            ),
        ];

        yield [
            new Dsn('ses+sdk', 'eu-west-1', null, null, null),
            new SesSdkTransport(
                $this->createConfig(self::DEFAULT_USER, self::DEFAULT_PASSWORD,'eu-west-1'),
                $dispatcher,
                $logger
            ),
        ];

        yield [
            new Dsn('ses+sdk', 'ap-south-2', null, null, null, [
                'ConfigurationSetName' => 'TestConfigSet',
            ]),
            new SesSdkTransport(
                $this->createConfig(self::DEFAULT_USER, self::DEFAULT_PASSWORD, 'ap-south-2', [
                    'ConfigurationSetName' => 'TestConfigSet'
                ]),
                $dispatcher,
                $logger
            ),
        ];
    }

    public function unsupportedSchemeProvider(): iterable
    {
        yield [
            new Dsn('foobar', 'default', self::USER, self::PASSWORD),
            'The "foobar" scheme is not supported.',
        ];
    }

    private function createConfig($key, $secret, $region, $options = [])
    {
        return new \Badams\AmazonMailerSdk\SesSdkTransportConfig(
            $this->createCredentialsResolver($key, $secret),
            $region,
            $options
        );
    }

    private function createCredentialsResolver($key, $secret)
    {
        return function () use ($key, $secret) {
            $promise = new Promise();
            $promise->resolve(new Credentials($key, $secret));
            return $promise;
        };
    }

    protected function getDispatcher(): EventDispatcherInterface
    {
        return $this->dispatcher ?? $this->dispatcher = $this->createMock(EventDispatcherInterface::class);

The property dispatcher does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

The expression return $this->dispatcher ?? $this->dispatcher = $this->createMock(Symfony\Contracts\EventDispatcher\EventDispatcherInterface::class) could return the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the type-hinted return Symfony\Contracts\EventDispatcher\EventDispatcherInterface. Consider adding an additional type-check to rule them out.

    }

    protected function getClient(): HttpClientInterface
    {
        return $this->client ?? $this->client = $this->createMock(HttpClientInterface::class);

The property client does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

The expression return $this->client ?? $this->client = $this->createMock(Symfony\Contracts\HttpClient\HttpClientInterface::class) could return the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the type-hinted return Symfony\Contracts\HttpClient\HttpClientInterface. Consider adding an additional type-check to rule them out.

    }

    protected function getLogger(): LoggerInterface
    {
        return $this->logger ?? $this->logger = $this->createMock(LoggerInterface::class);

The expression return $this->logger ?? $this->logger = $this->createMock(Psr\Log\LoggerInterface::class) could return the type PHPUnit\Framework\MockObject\MockObject which is incompatible with the type-hinted return Psr\Log\LoggerInterface. Consider adding an additional type-check to rule them out.

The property logger does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

    }
}