ImageServiceTest::testGetImageFromCache() - Code Metrics - hrevert/HtImgModule - Measure and Improve Code Quality continuously with Scrutinizer

ImageServiceTest::testGetImageFromCache() A
last analyzed 2018-04-27 19:04 UTC

↳ Parent: ImageServiceTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	53
Code Lines	42

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	53
rs	9.5797
c	0
b	0
f	0
cc	1
eloc	42
nc	1
nop	0

How to fix Long Method

<?php
namespace HtImgModuleTest\Service;

use HtImgModule\Service\ImageService;
use HtImgModule\Service\CacheManager;
use Imagine\Gd\Imagine;
use HtImgModule\Imagine\Filter\FilterManager;

class ImageServiceTest extends \PHPUnit_Framework_TestCase
{
    public function testGetImageFromCache()
    {
        $cacheManager =  $this->createMock('HtImgModule\Service\CacheManagerInterface');
        $cacheManager->expects($this->once())
            ->method('cacheExists')
            ->will($this->returnValue(true));
        $cacheManager->expects($this->once())
            ->method('getCachePath')
            ->will($this->returnValue(RESOURCES_DIR.'/flowers.jpg'));
        $imagine = $this->createMock('Imagine\Image\ImagineInterface');
        $filterManager = $this->createMock('HtImgModule\Imagine\Filter\FilterManagerInterface');
        $loaderManager = $this->createMock('HtImgModule\Imagine\Loader\LoaderManagerInterface');
        $imageService = new ImageService(
            $cacheManager,
            $imagine,
            $filterManager,
            $loaderManager
        );

        $relativePath = 'path/to/image/flowers.jpg';
        $filterName = 'foo_filter';

        $binary = $this->createMock('HtImgModule\Binary\BinaryInterface');
        $loaderManager->expects($this->once())
            ->method('loadBinary')
            ->with($relativePath, $filterName)
            ->will($this->returnValue($binary));

        $filterOptions = ['format' => 'gif', 'quality' => 87, 'animated' => true];

        $filterManager->expects($this->once())
            ->method('getFilterOptions')
            ->with('foo_filter')
            ->will($this->returnValue($filterOptions));

        $cacheManager->expects($this->once())
            ->method('isCachingEnabled')
            ->with('foo_filter', $filterOptions)
            ->will($this->returnValue(true));

        $image = $this->createMock('Imagine\Image\ImageInterface');
        $imagine->expects($this->once())
            ->method('open')
            ->with(RESOURCES_DIR.'/flowers.jpg')
            ->will($this->returnValue($image));

        $imageData = $imageService->getImage('path/to/image/flowers.jpg', 'foo_filter');

        $this->assertEquals($image, $imageData['image']);
        $this->assertEquals('gif', $imageData['format']);
        $this->assertEquals(87, $imageData['imageOutputOptions']['quality']);
        $this->assertEquals(true, $imageData['imageOutputOptions']['animated']);
    }

    public function testGetImageFromRelativePathAndCreateCache()
    {
        $cacheManager =  $this->createMock('HtImgModule\Service\CacheManagerInterface');
        $imagine = $this->createMock('Imagine\Image\ImagineInterface');
        $filterManager = $this->createMock('HtImgModule\Imagine\Filter\FilterManagerInterface');
        $loaderManager = $this->createMock('HtImgModule\Imagine\Loader\LoaderManagerInterface');
        $imageService = new ImageService(
            $cacheManager,
            $imagine,
            $filterManager,
            $loaderManager
        );

        $binaryContent = '35345fascxzcasdfhj;alsdkf4asldfkja;sldf65854';
        $relativePath = 'relative/path/to/image';
        $filterName = 'foo-bar-filter';

        $filterOptions = ['quality' => 87];

        $filterManager->expects($this->once())
            ->method('getFilterOptions')
            ->with($filterName)
            ->will($this->returnValue($filterOptions));

        $binary = $this->createMock('HtImgModule\Binary\BinaryInterface');
        $binary->expects($this->once())
            ->method('getContent')
            ->will($this->returnValue($binaryContent));
        $loaderManager->expects($this->once())
            ->method('loadBinary')
            ->with($relativePath, $filterName)
            ->will($this->returnValue($binary));

        $image = $this->createMock('Imagine\Image\ImageInterface');

        $imagine->expects($this->once())
            ->method('load')
            ->with($binaryContent)
            ->will($this->returnValue($image));

        $filteredImage = $this->createMock('Imagine\Image\ImageInterface');
        $filter = $this->createMock('Imagine\Filter\FilterInterface');
        $filter->expects($this->once())
            ->method('apply')
            ->with($image)
            ->will($this->returnValue($filteredImage));

        $filterManager->expects($this->once())
            ->method('getFilter')
            ->with($filterName)
            ->will($this->returnValue($filter));

        $cacheManager->expects($this->any())
            ->method('isCachingEnabled')
            ->with($filterName, $filterOptions)
            ->will($this->returnValue(true));

        $cacheManager->expects($this->once())
            ->method('createCache')
            ->with($relativePath, $filterName, $filteredImage, 'png', $filterOptions);

        $imageData = $imageService->getImage($relativePath, $filterName);

        $this->assertEquals($image, $imageData['image']);
    }
}


1			<?php
2			namespace HtImgModuleTest\Service;
3
4			use HtImgModule\Service\ImageService;
5			use HtImgModule\Service\CacheManager;
6			use Imagine\Gd\Imagine;
7			use HtImgModule\Imagine\Filter\FilterManager;
8
9			class ImageServiceTest extends \PHPUnit_Framework_TestCase
10			{
11			public function testGetImageFromCache()
12			{
13			$cacheManager = $this->createMock('HtImgModule\Service\CacheManagerInterface');
14			$cacheManager->expects($this->once())
15			->method('cacheExists')
16			->will($this->returnValue(true));
17			$cacheManager->expects($this->once())
18			->method('getCachePath')
19			->will($this->returnValue(RESOURCES_DIR.'/flowers.jpg'));
20			$imagine = $this->createMock('Imagine\Image\ImagineInterface');
21			$filterManager = $this->createMock('HtImgModule\Imagine\Filter\FilterManagerInterface');
22			$loaderManager = $this->createMock('HtImgModule\Imagine\Loader\LoaderManagerInterface');
23			$imageService = new ImageService(
24			$cacheManager,
25			$imagine,
26			$filterManager,
27			$loaderManager
28			);
29
30			$relativePath = 'path/to/image/flowers.jpg';
31			$filterName = 'foo_filter';
32
33			$binary = $this->createMock('HtImgModule\Binary\BinaryInterface');
34			$loaderManager->expects($this->once())
35			->method('loadBinary')
36			->with($relativePath, $filterName)
37			->will($this->returnValue($binary));
38
39			$filterOptions = ['format' => 'gif', 'quality' => 87, 'animated' => true];
40
41			$filterManager->expects($this->once())
42			->method('getFilterOptions')
43			->with('foo_filter')
44			->will($this->returnValue($filterOptions));
45
46			$cacheManager->expects($this->once())
47			->method('isCachingEnabled')
48			->with('foo_filter', $filterOptions)
49			->will($this->returnValue(true));
50
51			$image = $this->createMock('Imagine\Image\ImageInterface');
52			$imagine->expects($this->once())
53			->method('open')
54			->with(RESOURCES_DIR.'/flowers.jpg')
55			->will($this->returnValue($image));
56
57			$imageData = $imageService->getImage('path/to/image/flowers.jpg', 'foo_filter');
58
59			$this->assertEquals($image, $imageData['image']);
60			$this->assertEquals('gif', $imageData['format']);
61			$this->assertEquals(87, $imageData['imageOutputOptions']['quality']);
62			$this->assertEquals(true, $imageData['imageOutputOptions']['animated']);
63			}
64
65			public function testGetImageFromRelativePathAndCreateCache()
66			{
67			$cacheManager = $this->createMock('HtImgModule\Service\CacheManagerInterface');
68			$imagine = $this->createMock('Imagine\Image\ImagineInterface');
69			$filterManager = $this->createMock('HtImgModule\Imagine\Filter\FilterManagerInterface');
70			$loaderManager = $this->createMock('HtImgModule\Imagine\Loader\LoaderManagerInterface');
71			$imageService = new ImageService(
72			$cacheManager,
73			$imagine,
74			$filterManager,
75			$loaderManager
76			);
77
78			$binaryContent = '35345fascxzcasdfhj;alsdkf4asldfkja;sldf65854';
79			$relativePath = 'relative/path/to/image';
80			$filterName = 'foo-bar-filter';
81
82			$filterOptions = ['quality' => 87];
83
84			$filterManager->expects($this->once())
85			->method('getFilterOptions')
86			->with($filterName)
87			->will($this->returnValue($filterOptions));
88
89			$binary = $this->createMock('HtImgModule\Binary\BinaryInterface');
90			$binary->expects($this->once())
91			->method('getContent')
92			->will($this->returnValue($binaryContent));
93			$loaderManager->expects($this->once())
94			->method('loadBinary')
95			->with($relativePath, $filterName)
96			->will($this->returnValue($binary));
97
98			$image = $this->createMock('Imagine\Image\ImageInterface');
99
100			$imagine->expects($this->once())
101			->method('load')
102			->with($binaryContent)
103			->will($this->returnValue($image));
104
105			$filteredImage = $this->createMock('Imagine\Image\ImageInterface');
106			$filter = $this->createMock('Imagine\Filter\FilterInterface');
107			$filter->expects($this->once())
108			->method('apply')
109			->with($image)
110			->will($this->returnValue($filteredImage));
111
112			$filterManager->expects($this->once())
113			->method('getFilter')
114			->with($filterName)
115			->will($this->returnValue($filter));
116
117			$cacheManager->expects($this->any())
118			->method('isCachingEnabled')
119			->with($filterName, $filterOptions)
120			->will($this->returnValue(true));
121
122			$cacheManager->expects($this->once())
123			->method('createCache')
124			->with($relativePath, $filterName, $filteredImage, 'png', $filterOptions);
125
126			$imageData = $imageService->getImage($relativePath, $filterName);
127
128			$this->assertEquals($image, $imageData['image']);
129			}
130			}
131

hrevert / HtImgModule

GitHub Access Token became invalid

ImageServiceTest::testGetImageFromCache() A last analyzed 2018-04-27 19:04 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

ImageServiceTest::testGetImageFromCache() A
last analyzed 2018-04-27 19:04 UTC