ProxyMetadataBuilderTest::getContainerMock() - Code Metrics - Inspection of "Manual merge" - sonata-project/SonataMediaBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#1726)

by Grégoire

created 2020-03-25 07:43 UTC

ProxyMetadataBuilderTest::getContainerMock() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	18
rs	9.6666
c	0
b	0
f	0
cc	1
nc	1
nop	1

<?php

declare(strict_types=1);

/*
 * This file is part of the Sonata Project package.
 *
 * (c) Thomas Rabaix <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sonata\MediaBundle\Tests\Metadata;

use Aws\S3\S3Client;
use Gaufrette\Adapter\AwsS3;
use Gaufrette\Filesystem;
use PHPUnit\Framework\TestCase;
use Sonata\MediaBundle\Filesystem\Local;
use Sonata\MediaBundle\Filesystem\Replicate;
use Sonata\MediaBundle\Metadata\AmazonMetadataBuilder;
use Sonata\MediaBundle\Metadata\NoopMetadataBuilder;
use Sonata\MediaBundle\Metadata\ProxyMetadataBuilder;
use Sonata\MediaBundle\Model\MediaInterface;
use Sonata\MediaBundle\Provider\MediaProviderInterface;
use Symfony\Component\DependencyInjection\Container;

class ProxyMetadataBuilderTest extends TestCase
{
    public function testProxyAmazon(): void
    {
        $amazon = $this->createMock(AmazonMetadataBuilder::class);
        $amazon->expects($this->once())
            ->method('get')
            ->willReturn(['key' => 'amazon']);

        $noop = $this->createMock(NoopMetadataBuilder::class);
        $noop->expects($this->never())
            ->method('get')
            ->willReturn(['key' => 'noop']);

        //adapter cannot be mocked
        $amazonclient = S3Client::factory([
            'credentials' => [
                'key' => 'XXXXXXXXXXXX',
                'secret' => 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
            ],
            'region' => 'us-west-1',
        ]);
        $adapter = new AwsS3($amazonclient, '');

        $filesystem = $this->createMock(Filesystem::class);
        $filesystem->method('getAdapter')->willReturn($adapter);

        $provider = $this->createMock(MediaProviderInterface::class);
        $provider->method('getFilesystem')->willReturn($filesystem);

        $media = $this->createMock(MediaInterface::class);
        $media
            ->method('getProviderName')
            ->willReturn('sonata.media.provider.image');

        $filename = '/test/folder/testfile.png';

        $container = $this->getContainer([
            'sonata.media.metadata.noop' => $noop,
            'sonata.media.metadata.amazon' => $amazon,
            'sonata.media.provider.image' => $provider,
        ]);

        $proxymetadatabuilder = new ProxyMetadataBuilder($container);

        $this->assertSame(['key' => 'amazon'], $proxymetadatabuilder->get($media, $filename));
    }

    public function testProxyLocal(): void
    {
        $amazon = $this->createMock(AmazonMetadataBuilder::class);
        $amazon->expects($this->never())
            ->method('get')
            ->willReturn(['key' => 'amazon']);

        $noop = $this->createMock(NoopMetadataBuilder::class);
        $noop->expects($this->once())
            ->method('get')
            ->willReturn(['key' => 'noop']);

        //adapter cannot be mocked
        $adapter = new Local('');

        $filesystem = $this->createMock(Filesystem::class);
        $filesystem->method('getAdapter')->willReturn($adapter);

        $provider = $this->createMock(MediaProviderInterface::class);
        $provider->method('getFilesystem')->willReturn($filesystem);

        $media = $this->createMock(MediaInterface::class);
        $media
            ->method('getProviderName')
            ->willReturn('sonata.media.provider.image');

        $filename = '/test/folder/testfile.png';

        $container = $this->getContainer([
            'sonata.media.metadata.noop' => $noop,
            'sonata.media.metadata.amazon' => $amazon,
            'sonata.media.provider.image' => $provider,
        ]);

        $proxymetadatabuilder = new ProxyMetadataBuilder($container);

        $this->assertSame(['key' => 'noop'], $proxymetadatabuilder->get($media, $filename));
    }

    public function testProxyNoProvider(): void
    {
        $amazon = $this->createMock(AmazonMetadataBuilder::class);
        $amazon->expects($this->never())
            ->method('get')
            ->willReturn(['key' => 'amazon']);

        $noop = $this->createMock(NoopMetadataBuilder::class);
        $noop->expects($this->never())
            ->method('get')
            ->willReturn(['key' => 'noop']);

        //adapter cannot be mocked
        $adapter = new Local('');

        $filesystem = $this->createMock(Filesystem::class);
        $filesystem->method('getAdapter')->willReturn($adapter);

        $provider = $this->createMock(MediaProviderInterface::class);
        $provider->method('getFilesystem')->willReturn($filesystem);

        $media = $this->createMock(MediaInterface::class);
        $media
            ->method('getProviderName')
            ->willReturn('wrongprovider');

        $filename = '/test/folder/testfile.png';

        $container = $this->getContainer([
            'sonata.media.metadata.noop' => $noop,
            'sonata.media.metadata.amazon' => $amazon,
            'sonata.media.provider.image' => $provider,
        ]);

        $proxymetadatabuilder = new ProxyMetadataBuilder($container);

        $this->assertSame([], $proxymetadatabuilder->get($media, $filename));
    }

    public function testProxyReplicateWithAmazon(): void
    {
        $amazon = $this->createMock(AmazonMetadataBuilder::class);
        $amazon->expects($this->once())
            ->method('get')
            ->willReturn(['key' => 'amazon']);

        $noop = $this->createMock(NoopMetadataBuilder::class);
        $noop->expects($this->never())
            ->method('get')
            ->willReturn(['key' => 'noop']);

        //adapter cannot be mocked
        $amazonclient = S3Client::factory([
            'credentials' => [
                'key' => 'XXXXXXXXXXXX',
                'secret' => 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
            ],
            'region' => 'us-west-1',
        ]);
        $adapter1 = new AwsS3($amazonclient, '');
        $adapter2 = new Local('');
        $adapter = new Replicate($adapter1, $adapter2);

        $filesystem = $this->createMock(Filesystem::class);
        $filesystem->method('getAdapter')->willReturn($adapter);

        $provider = $this->createMock(MediaProviderInterface::class);
        $provider->method('getFilesystem')->willReturn($filesystem);

        $media = $this->createMock(MediaInterface::class);
        $media
            ->method('getProviderName')
            ->willReturn('sonata.media.provider.image');

        $filename = '/test/folder/testfile.png';

        $container = $this->getContainer([
            'sonata.media.metadata.noop' => $noop,
            'sonata.media.metadata.amazon' => $amazon,
            'sonata.media.provider.image' => $provider,
        ]);

        $proxymetadatabuilder = new ProxyMetadataBuilder($container);

        $this->assertSame(['key' => 'amazon'], $proxymetadatabuilder->get($media, $filename));
    }

    public function testProxyReplicateWithoutAmazon(): void
    {
        $amazon = $this->createMock(AmazonMetadataBuilder::class);
        $amazon->expects($this->never())
            ->method('get')
            ->willReturn(['key' => 'amazon']);

        $noop = $this->createMock(NoopMetadataBuilder::class);
        $noop->expects($this->once())
            ->method('get')
            ->willReturn(['key' => 'noop']);

        //adapter cannot be mocked
        $adapter1 = new Local('');
        $adapter2 = new Local('');
        $adapter = new Replicate($adapter1, $adapter2);

        $filesystem = $this->createMock(Filesystem::class);
        $filesystem->method('getAdapter')->willReturn($adapter);

        $provider = $this->createMock(MediaProviderInterface::class);
        $provider->method('getFilesystem')->willReturn($filesystem);

        $media = $this->createMock(MediaInterface::class);
        $media
            ->method('getProviderName')
            ->willReturn('sonata.media.provider.image');

        $filename = '/test/folder/testfile.png';

        $container = $this->getContainer([
            'sonata.media.metadata.noop' => $noop,
            'sonata.media.metadata.amazon' => $amazon,
            'sonata.media.provider.image' => $provider,
        ]);

        $proxymetadatabuilder = new ProxyMetadataBuilder($container);

        $this->assertSame(['key' => 'noop'], $proxymetadatabuilder->get($media, $filename));
    }

    protected function getContainer(array $services): Container
    {
        $container = new Container();

        foreach ($services as $serviceId => $service) {
            $container->set($serviceId, $service);
        }

        return $container;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the Sonata Project package.
7			*
8			* (c) Thomas Rabaix <[email protected]>
9			*
10			* For the full copyright and license information, please view the LICENSE
11			* file that was distributed with this source code.
12			*/
13
14			namespace Sonata\MediaBundle\Tests\Metadata;
15
16			use Aws\S3\S3Client;
17			use Gaufrette\Adapter\AwsS3;
18			use Gaufrette\Filesystem;
19			use PHPUnit\Framework\TestCase;
20			use Sonata\MediaBundle\Filesystem\Local;
21			use Sonata\MediaBundle\Filesystem\Replicate;
22			use Sonata\MediaBundle\Metadata\AmazonMetadataBuilder;
23			use Sonata\MediaBundle\Metadata\NoopMetadataBuilder;
24			use Sonata\MediaBundle\Metadata\ProxyMetadataBuilder;
25			use Sonata\MediaBundle\Model\MediaInterface;
26			use Sonata\MediaBundle\Provider\MediaProviderInterface;
27			use Symfony\Component\DependencyInjection\Container;
28
29			class ProxyMetadataBuilderTest extends TestCase
30			{
31			public function testProxyAmazon(): void
32			{
33			$amazon = $this->createMock(AmazonMetadataBuilder::class);
34			$amazon->expects($this->once())
35			->method('get')
36			->willReturn(['key' => 'amazon']);
37
38			$noop = $this->createMock(NoopMetadataBuilder::class);
39			$noop->expects($this->never())
40			->method('get')
41			->willReturn(['key' => 'noop']);
42
43			//adapter cannot be mocked
44			$amazonclient = S3Client::factory([
45			'credentials' => [
46			'key' => 'XXXXXXXXXXXX',
47			'secret' => 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
48			],
49			'region' => 'us-west-1',
50			]);
51			$adapter = new AwsS3($amazonclient, '');
52
53			$filesystem = $this->createMock(Filesystem::class);
54			$filesystem->method('getAdapter')->willReturn($adapter);
55
56			$provider = $this->createMock(MediaProviderInterface::class);
57			$provider->method('getFilesystem')->willReturn($filesystem);
58
59			$media = $this->createMock(MediaInterface::class);
60			$media
61			->method('getProviderName')
62			->willReturn('sonata.media.provider.image');
63
64			$filename = '/test/folder/testfile.png';
65
66			$container = $this->getContainer([
67			'sonata.media.metadata.noop' => $noop,
68			'sonata.media.metadata.amazon' => $amazon,
69			'sonata.media.provider.image' => $provider,
70			]);
71
72			$proxymetadatabuilder = new ProxyMetadataBuilder($container);
73
74			$this->assertSame(['key' => 'amazon'], $proxymetadatabuilder->get($media, $filename));
75			}
76
77			public function testProxyLocal(): void
78			{
79			$amazon = $this->createMock(AmazonMetadataBuilder::class);
80			$amazon->expects($this->never())
81			->method('get')
82			->willReturn(['key' => 'amazon']);
83
84			$noop = $this->createMock(NoopMetadataBuilder::class);
85			$noop->expects($this->once())
86			->method('get')
87			->willReturn(['key' => 'noop']);
88
89			//adapter cannot be mocked
90			$adapter = new Local('');
91
92			$filesystem = $this->createMock(Filesystem::class);
93			$filesystem->method('getAdapter')->willReturn($adapter);
94
95			$provider = $this->createMock(MediaProviderInterface::class);
96			$provider->method('getFilesystem')->willReturn($filesystem);
97
98			$media = $this->createMock(MediaInterface::class);
99			$media
100			->method('getProviderName')
101			->willReturn('sonata.media.provider.image');
102
103			$filename = '/test/folder/testfile.png';
104
105			$container = $this->getContainer([
106			'sonata.media.metadata.noop' => $noop,
107			'sonata.media.metadata.amazon' => $amazon,
108			'sonata.media.provider.image' => $provider,
109			]);
110
111			$proxymetadatabuilder = new ProxyMetadataBuilder($container);
112
113			$this->assertSame(['key' => 'noop'], $proxymetadatabuilder->get($media, $filename));
114			}
115
116			public function testProxyNoProvider(): void
117			{
118			$amazon = $this->createMock(AmazonMetadataBuilder::class);
119			$amazon->expects($this->never())
120			->method('get')
121			->willReturn(['key' => 'amazon']);
122
123			$noop = $this->createMock(NoopMetadataBuilder::class);
124			$noop->expects($this->never())
125			->method('get')
126			->willReturn(['key' => 'noop']);
127
128			//adapter cannot be mocked
129			$adapter = new Local('');
130
131			$filesystem = $this->createMock(Filesystem::class);
132			$filesystem->method('getAdapter')->willReturn($adapter);
133
134			$provider = $this->createMock(MediaProviderInterface::class);
135			$provider->method('getFilesystem')->willReturn($filesystem);
136
137			$media = $this->createMock(MediaInterface::class);
138			$media
139			->method('getProviderName')
140			->willReturn('wrongprovider');
141
142			$filename = '/test/folder/testfile.png';
143
144			$container = $this->getContainer([
145			'sonata.media.metadata.noop' => $noop,
146			'sonata.media.metadata.amazon' => $amazon,
147			'sonata.media.provider.image' => $provider,
148			]);
149
150			$proxymetadatabuilder = new ProxyMetadataBuilder($container);
151
152			$this->assertSame([], $proxymetadatabuilder->get($media, $filename));
153			}
154
155			public function testProxyReplicateWithAmazon(): void
156			{
157			$amazon = $this->createMock(AmazonMetadataBuilder::class);
158			$amazon->expects($this->once())
159			->method('get')
160			->willReturn(['key' => 'amazon']);
161
162			$noop = $this->createMock(NoopMetadataBuilder::class);
163			$noop->expects($this->never())
164			->method('get')
165			->willReturn(['key' => 'noop']);
166
167			//adapter cannot be mocked
168			$amazonclient = S3Client::factory([
169			'credentials' => [
170			'key' => 'XXXXXXXXXXXX',
171			'secret' => 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX',
172			],
173			'region' => 'us-west-1',
174			]);
175			$adapter1 = new AwsS3($amazonclient, '');
176			$adapter2 = new Local('');
177			$adapter = new Replicate($adapter1, $adapter2);
178
179			$filesystem = $this->createMock(Filesystem::class);
180			$filesystem->method('getAdapter')->willReturn($adapter);
181
182			$provider = $this->createMock(MediaProviderInterface::class);
183			$provider->method('getFilesystem')->willReturn($filesystem);
184
185			$media = $this->createMock(MediaInterface::class);
186			$media
187			->method('getProviderName')
188			->willReturn('sonata.media.provider.image');
189
190			$filename = '/test/folder/testfile.png';
191
192			$container = $this->getContainer([
193			'sonata.media.metadata.noop' => $noop,
194			'sonata.media.metadata.amazon' => $amazon,
195			'sonata.media.provider.image' => $provider,
196			]);
197
198			$proxymetadatabuilder = new ProxyMetadataBuilder($container);
199
200			$this->assertSame(['key' => 'amazon'], $proxymetadatabuilder->get($media, $filename));
201			}
202
203			public function testProxyReplicateWithoutAmazon(): void
204			{
205			$amazon = $this->createMock(AmazonMetadataBuilder::class);
206			$amazon->expects($this->never())
207			->method('get')
208			->willReturn(['key' => 'amazon']);
209
210			$noop = $this->createMock(NoopMetadataBuilder::class);
211			$noop->expects($this->once())
212			->method('get')
213			->willReturn(['key' => 'noop']);
214
215			//adapter cannot be mocked
216			$adapter1 = new Local('');
217			$adapter2 = new Local('');
218			$adapter = new Replicate($adapter1, $adapter2);
219
220			$filesystem = $this->createMock(Filesystem::class);
221			$filesystem->method('getAdapter')->willReturn($adapter);
222
223			$provider = $this->createMock(MediaProviderInterface::class);
224			$provider->method('getFilesystem')->willReturn($filesystem);
225
226			$media = $this->createMock(MediaInterface::class);
227			$media
228			->method('getProviderName')
229			->willReturn('sonata.media.provider.image');
230
231			$filename = '/test/folder/testfile.png';
232
233			$container = $this->getContainer([
234			'sonata.media.metadata.noop' => $noop,
235			'sonata.media.metadata.amazon' => $amazon,
236			'sonata.media.provider.image' => $provider,
237			]);
238
239			$proxymetadatabuilder = new ProxyMetadataBuilder($container);
240
241			$this->assertSame(['key' => 'noop'], $proxymetadatabuilder->get($media, $filename));
242			}
243
244			protected function getContainer(array $services): Container
245			{
246			$container = new Container();
247
248			foreach ($services as $serviceId => $service) {
249			$container->set($serviceId, $service);
250			}
251
252			return $container;
253			}
254			}
255

sonata-project / SonataMediaBundle

Pull Request — master (#1726)

ProxyMetadataBuilderTest::getContainerMock() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like