HtImgModuleTest\Service\ImageServiceTest

Complexity

Total Complexity

2

Size/Duplication

Total Lines	122
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	2
Bugs	1	Features	0

2 Methods

Rating	Name	Duplication	Size	Complexity
A	testGetImageFromCache()	0	53	1
A	testGetImageFromRelativePathAndCreateCache()	0	65	1

<?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']);
    }
}