ProxyMetadataBuilderTest::testProxyReplicateWithAmazon() - Code Metrics - Inspection of "Merge 3.x into master" - sonata-project/SonataMediaBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 0059de...8f5e7c )

unknown

created 2018-02-23 01:00 UTC

testProxyReplicateWithAmazon() A

↳ Parent: ProxyMetadataBuilderTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	47
Code Lines	32

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	47
rs	9.0303
c	0
b	0
f	0
cc	1
eloc	32
nc	1
nop	0

<?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\ContainerInterface;

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

        $noop = $this->createMock(NoopMetadataBuilder::class);
        $noop->expects($this->never())
            ->method('get')
            ->will($this->returnValue(['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->expects($this->any())->method('getAdapter')->will($this->returnValue($adapter));

        $provider = $this->createMock(MediaProviderInterface::class);
        $provider->expects($this->any())->method('getFilesystem')->will($this->returnValue($filesystem));

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

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

        $container = $this->getContainerMock([
            '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')
            ->will($this->returnValue(['key' => 'amazon']));

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

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

        $filesystem = $this->createMock(Filesystem::class);
        $filesystem->expects($this->any())->method('getAdapter')->will($this->returnValue($adapter));

        $provider = $this->createMock(MediaProviderInterface::class);
        $provider->expects($this->any())->method('getFilesystem')->will($this->returnValue($filesystem));

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

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

        $container = $this->getContainerMock([
            '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')
            ->will($this->returnValue(['key' => 'amazon']));

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

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

        $filesystem = $this->createMock(Filesystem::class);
        $filesystem->expects($this->any())->method('getAdapter')->will($this->returnValue($adapter));

        $provider = $this->createMock(MediaProviderInterface::class);
        $provider->expects($this->any())->method('getFilesystem')->will($this->returnValue($filesystem));

        $media = $this->createMock(MediaInterface::class);
        $media->expects($this->any())
            ->method('getProviderName')
            ->will($this->returnValue('wrongprovider'));

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

        $container = $this->getContainerMock([
            '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')
            ->will($this->returnValue(['key' => 'amazon']));

        $noop = $this->createMock(NoopMetadataBuilder::class);
        $noop->expects($this->never())
            ->method('get')
            ->will($this->returnValue(['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->expects($this->any())->method('getAdapter')->will($this->returnValue($adapter));

        $provider = $this->createMock(MediaProviderInterface::class);
        $provider->expects($this->any())->method('getFilesystem')->will($this->returnValue($filesystem));

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

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

        $container = $this->getContainerMock([
            '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')
            ->will($this->returnValue(['key' => 'amazon']));

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

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

        $filesystem = $this->createMock(Filesystem::class);
        $filesystem->expects($this->any())->method('getAdapter')->will($this->returnValue($adapter));

        $provider = $this->createMock(MediaProviderInterface::class);
        $provider->expects($this->any())->method('getFilesystem')->will($this->returnValue($filesystem));

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

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

        $container = $this->getContainerMock([
            '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));
    }

    /**
     * Return a mock object for the DI ContainerInterface.
     *
     * @param array $services A key-value list of services the container contains
     *
     * @return \PHPUnit_Framework_MockObject_MockObject
     */
    protected function getContainerMock(array $services)
    {
        $container = $this->createMock(ContainerInterface::class);
        $container
            ->expects($this->any())
            ->method('get')
            ->will($this->returnCallback(function ($service) use ($services) {
                return $services[$service];
            }))
        ;
        $container
            ->expects($this->any())
            ->method('has')
            ->will($this->returnCallback(function ($service) use ($services) {
                if (isset($services[$service])) {
                    return true;
                }

                return false;
            }))
        ;

        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\ContainerInterface;
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			->will($this->returnValue(['key' => 'amazon']));
37
38			$noop = $this->createMock(NoopMetadataBuilder::class);
39			$noop->expects($this->never())
40			->method('get')
41			->will($this->returnValue(['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->expects($this->any())->method('getAdapter')->will($this->returnValue($adapter));
55
56			$provider = $this->createMock(MediaProviderInterface::class);
57			$provider->expects($this->any())->method('getFilesystem')->will($this->returnValue($filesystem));
58
59			$media = $this->createMock(MediaInterface::class);
60			$media->expects($this->any())
61			->method('getProviderName')
62			->will($this->returnValue('sonata.media.provider.image'));
63
64			$filename = '/test/folder/testfile.png';
65
66			$container = $this->getContainerMock([
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			->will($this->returnValue(['key' => 'amazon']));
83
84			$noop = $this->createMock(NoopMetadataBuilder::class);
85			$noop->expects($this->once())
86			->method('get')
87			->will($this->returnValue(['key' => 'noop']));
88
89			//adapter cannot be mocked
90			$adapter = new Local('');
91
92			$filesystem = $this->createMock(Filesystem::class);
93			$filesystem->expects($this->any())->method('getAdapter')->will($this->returnValue($adapter));
94
95			$provider = $this->createMock(MediaProviderInterface::class);
96			$provider->expects($this->any())->method('getFilesystem')->will($this->returnValue($filesystem));
97
98			$media = $this->createMock(MediaInterface::class);
99			$media->expects($this->any())
100			->method('getProviderName')
101			->will($this->returnValue('sonata.media.provider.image'));
102
103			$filename = '/test/folder/testfile.png';
104
105			$container = $this->getContainerMock([
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			->will($this->returnValue(['key' => 'amazon']));
122
123			$noop = $this->createMock(NoopMetadataBuilder::class);
124			$noop->expects($this->never())
125			->method('get')
126			->will($this->returnValue(['key' => 'noop']));
127
128			//adapter cannot be mocked
129			$adapter = new Local('');
130
131			$filesystem = $this->createMock(Filesystem::class);
132			$filesystem->expects($this->any())->method('getAdapter')->will($this->returnValue($adapter));
133
134			$provider = $this->createMock(MediaProviderInterface::class);
135			$provider->expects($this->any())->method('getFilesystem')->will($this->returnValue($filesystem));
136
137			$media = $this->createMock(MediaInterface::class);
138			$media->expects($this->any())
139			->method('getProviderName')
140			->will($this->returnValue('wrongprovider'));
141
142			$filename = '/test/folder/testfile.png';
143
144			$container = $this->getContainerMock([
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			->will($this->returnValue(['key' => 'amazon']));
161
162			$noop = $this->createMock(NoopMetadataBuilder::class);
163			$noop->expects($this->never())
164			->method('get')
165			->will($this->returnValue(['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->expects($this->any())->method('getAdapter')->will($this->returnValue($adapter));
181
182			$provider = $this->createMock(MediaProviderInterface::class);
183			$provider->expects($this->any())->method('getFilesystem')->will($this->returnValue($filesystem));
184
185			$media = $this->createMock(MediaInterface::class);
186			$media->expects($this->any())
187			->method('getProviderName')
188			->will($this->returnValue('sonata.media.provider.image'));
189
190			$filename = '/test/folder/testfile.png';
191
192			$container = $this->getContainerMock([
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			->will($this->returnValue(['key' => 'amazon']));
209
210			$noop = $this->createMock(NoopMetadataBuilder::class);
211			$noop->expects($this->once())
212			->method('get')
213			->will($this->returnValue(['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->expects($this->any())->method('getAdapter')->will($this->returnValue($adapter));
222
223			$provider = $this->createMock(MediaProviderInterface::class);
224			$provider->expects($this->any())->method('getFilesystem')->will($this->returnValue($filesystem));
225
226			$media = $this->createMock(MediaInterface::class);
227			$media->expects($this->any())
228			->method('getProviderName')
229			->will($this->returnValue('sonata.media.provider.image'));
230
231			$filename = '/test/folder/testfile.png';
232
233			$container = $this->getContainerMock([
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			/**
245			* Return a mock object for the DI ContainerInterface.
246			*
247			* @param array $services A key-value list of services the container contains
248			*
249			* @return \PHPUnit_Framework_MockObject_MockObject
250			*/
251			protected function getContainerMock(array $services)
252			{
253			$container = $this->createMock(ContainerInterface::class);
254			$container
255			->expects($this->any())
256			->method('get')
257			->will($this->returnCallback(function ($service) use ($services) {
258			return $services[$service];
259			}))
260			;
261			$container
262			->expects($this->any())
263			->method('has')
264			->will($this->returnCallback(function ($service) use ($services) {
265			if (isset($services[$service])) {
266			return true;
267			}
268
269			return false;
270			}))
271			;
272
273			return $container;
274			}
275			}
276

sonata-project / SonataMediaBundle

Push — master ( 0059de...8f5e7c )

testProxyReplicateWithAmazon() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like