FilterManagerTest::testAlters100QualityIfNotSetOnApplyFilter() - Code Metrics - Inspection of "add @Event annotation to let IDEs known event name..." - liip/LiipImagineBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#732)

by 12345
created 2016-05-05 10:14 UTC
testAlters100QualityIfNotSetOnApplyFilter() A

↳ Parent: FilterManagerTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	57
Code Lines	39
Duplication

Lines	57
Ratio	100 %
Metric	Value
dl	57
loc	57
rs	9.6818
cc	1
eloc	39
nc	1
nop	0
How to fix Long Method

<?php

namespace Liip\ImagineBundle\Tests\Filter;

use Liip\ImagineBundle\Imagine\Filter\FilterManager;
use Liip\ImagineBundle\Imagine\Filter\Loader\LoaderInterface;
use Liip\ImagineBundle\Model\Binary;
use Liip\ImagineBundle\Tests\AbstractTest;

/**
 * @covers Liip\ImagineBundle\Imagine\Filter\FilterManager
 */
class FilterManagerTest extends AbstractTest
{
    public function testThrowsIfNoLoadersAddedForFilterOnApplyFilter()
    {
        $config = $this->createFilterConfigurationMock();
        $config
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->atLeastOnce())
            ->method('get')
            ->with('thumbnail')
            ->will($this->returnValue(array(
                'filters' => array(
                    'thumbnail' => array(
                        'size' => array(180, 180),
                        'mode' => 'outbound',
                    ),
                ),
                'post_processors' => array(),
            )))
        ;

        $binary = new Binary('aContent', 'image/png', 'png');

        $filterManager = new FilterManager(
            $config,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $this->createImagineMock(),
            $this->getMockMimeTypeGuesser()

        );

        $this->setExpectedException('InvalidArgumentException', 'Could not find filter loader for "thumbnail" filter type');
        $filterManager->applyFilter($binary, 'thumbnail');
    }

    public function testReturnFilteredBinaryWithExpectedContentOnApplyFilter()

    {
        $originalContent = 'aOriginalContent';
        $expectedFilteredContent = 'theFilteredContent';

        $binary = new Binary($originalContent, 'image/png', 'png');

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $config = $this->createFilterConfigurationMock();
        $config
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->atLeastOnce())
            ->method('get')
            ->with('thumbnail')
            ->will($this->returnValue(array(
                'filters' => array(
                    'thumbnail' => $thumbConfig,
                ),
                'post_processors' => array(),
            )))
        ;

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($expectedFilteredContent))
        ;

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

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $config,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $imagine,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $filteredBinary = $filterManager->applyFilter($binary, 'thumbnail');

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
        $this->assertEquals($expectedFilteredContent, $filteredBinary->getContent());
    }

    public function testReturnFilteredBinaryWithFormatOfOriginalBinaryOnApplyFilter()

    {
        $originalContent = 'aOriginalContent';
        $expectedFormat = 'png';

        $binary = new Binary($originalContent, 'image/png', $expectedFormat);

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $config = $this->createFilterConfigurationMock();
        $config
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->atLeastOnce())
            ->method('get')
            ->with('thumbnail')
            ->will($this->returnValue(array(
                'filters' => array(
                    'thumbnail' => $thumbConfig,
                ),
                'post_processors' => array(),
            )))
        ;

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue('aFilteredContent'))
        ;

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

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $config,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $imagine,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $filteredBinary = $filterManager->applyFilter($binary, 'thumbnail');

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
        $this->assertEquals($expectedFormat, $filteredBinary->getFormat());
    }

    public function testReturnFilteredBinaryWithCustomFormatIfSetOnApplyFilter()

    {
        $originalContent = 'aOriginalContent';
        $originalFormat = 'png';
        $expectedFormat = 'jpg';

        $binary = new Binary($originalContent, 'image/png', $originalFormat);

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $config = $this->createFilterConfigurationMock();
        $config
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->atLeastOnce())
            ->method('get')
            ->with('thumbnail')
            ->will($this->returnValue(array(
                'format' => $expectedFormat,
                'filters' => array(
                    'thumbnail' => $thumbConfig,
                ),
                'post_processors' => array(),
            )))
        ;

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue('aFilteredContent'))
        ;

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

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $config,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $imagine,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $filteredBinary = $filterManager->applyFilter($binary, 'thumbnail');

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
        $this->assertEquals($expectedFormat, $filteredBinary->getFormat());
    }

    public function testReturnFilteredBinaryWithMimeTypeOfOriginalBinaryOnApplyFilter()
    {
        $originalContent = 'aOriginalContent';
        $expectedMimeType = 'image/png';

        $binary = new Binary($originalContent, $expectedMimeType, 'png');

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $config = $this->createFilterConfigurationMock();
        $config
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->atLeastOnce())
            ->method('get')
            ->with('thumbnail')
            ->will($this->returnValue(array(
                'filters' => array(
                    'thumbnail' => $thumbConfig,
                ),
                'post_processors' => array(),
            )))
        ;

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue('aFilteredContent'))
        ;

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

        $mimeTypeGuesser = $this->getMockMimeTypeGuesser();
        $mimeTypeGuesser
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->never())
            ->method('guess')
        ;

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $config,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $imagine,
            $mimeTypeGuesser
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $filteredBinary = $filterManager->applyFilter($binary, 'thumbnail');

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
        $this->assertEquals($expectedMimeType, $filteredBinary->getMimeType());
    }

    public function testReturnFilteredBinaryWithMimeTypeOfCustomFormatIfSetOnApplyFilter()
    {
        $originalContent = 'aOriginalContent';
        $originalMimeType = 'image/png';
        $expectedContent = 'aFilteredContent';
        $expectedMimeType = 'image/jpeg';

        $binary = new Binary($originalContent, $originalMimeType, 'png');

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $config = $this->createFilterConfigurationMock();
        $config
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->atLeastOnce())
            ->method('get')
            ->with('thumbnail')
            ->will($this->returnValue(array(
                'format' => 'jpg',
                'filters' => array(
                    'thumbnail' => $thumbConfig,
                ),
                'post_processors' => array(),
            )))
        ;

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($expectedContent))
        ;

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

        $mimeTypeGuesser = $this->getMockMimeTypeGuesser();
        $mimeTypeGuesser
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('guess')
            ->with($expectedContent)
            ->will($this->returnValue($expectedMimeType))
        ;

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $config,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $imagine,
            $mimeTypeGuesser
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $filteredBinary = $filterManager->applyFilter($binary, 'thumbnail');

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
        $this->assertEquals($expectedMimeType, $filteredBinary->getMimeType());
    }

    public function testAltersQualityOnApplyFilter()

    {
        $originalContent = 'aOriginalContent';
        $expectedQuality = 80;

        $binary = new Binary($originalContent, 'image/png', 'png');

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $config = $this->createFilterConfigurationMock();
        $config
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->atLeastOnce())
            ->method('get')
            ->with('thumbnail')
            ->will($this->returnValue(array(
                'quality' => $expectedQuality,
                'filters' => array(
                    'thumbnail' => $thumbConfig,
                ),
                'post_processors' => array(),
            )))
        ;

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->with('png', array('quality' => $expectedQuality))
            ->will($this->returnValue('aFilteredContent'))
        ;

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

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $config,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $imagine,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filterManager->applyFilter($binary, 'thumbnail'));
    }

    public function testAlters100QualityIfNotSetOnApplyFilter()

    {
        $originalContent = 'aOriginalContent';
        $expectedQuality = 100;

        $binary = new Binary($originalContent, 'image/png', 'png');

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $config = $this->createFilterConfigurationMock();
        $config
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->atLeastOnce())
            ->method('get')
            ->with('thumbnail')
            ->will($this->returnValue(array(
                'filters' => array(
                    'thumbnail' => $thumbConfig,
                ),
                'post_processors' => array(),
            )))
        ;

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->with('png', array('quality' => $expectedQuality))
            ->will($this->returnValue('aFilteredContent'))
        ;

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

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $config,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $imagine,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filterManager->applyFilter($binary, 'thumbnail'));
    }

    public function testMergeRuntimeConfigWithOneFromFilterConfigurationOnApplyFilter()
    {
        $binary = new Binary('aContent', 'image/png', 'png');

        $runtimeConfig = array(
            'filters' => array(
                'thumbnail' => array(
                    'size' => array(100, 100),
                ),
            ),
            'post_processors' => array(),
        );

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $thumbMergedConfig = array(
            'size' => array(100, 100),
            'mode' => 'outbound',
        );

        $config = $this->createFilterConfigurationMock();
        $config
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->atLeastOnce())
            ->method('get')
            ->with('thumbnail')
            ->will($this->returnValue(array(
                'filters' => array(
                    'thumbnail' => $thumbConfig,
                ),
                'post_processors' => array(),
            )))
        ;

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue('aFilteredContent'))
        ;

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

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbMergedConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $config,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $imagine,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertInstanceOf(
            'Liip\ImagineBundle\Model\Binary',
            $filterManager->applyFilter($binary, 'thumbnail', $runtimeConfig)
        );
    }

    public function testThrowsIfNoLoadersAddedForFilterOnApply()
    {
        $binary = new Binary('aContent', 'image/png', 'png');

        $filterManager = new FilterManager(
            $this->createFilterConfigurationMock(),

            $this->createImagineMock(),
            $this->getMockMimeTypeGuesser()

        );

        $this->setExpectedException('InvalidArgumentException', 'Could not find filter loader for "thumbnail" filter type');
        $filterManager->apply($binary, array(
            'filters' => array(
                'thumbnail' => array(
                    'size' => array(180, 180),
                    'mode' => 'outbound',
                ),
            ),
        ));
    }

    public function testReturnFilteredBinaryWithExpectedContentOnApply()

    {
        $originalContent = 'aOriginalContent';
        $expectedFilteredContent = 'theFilteredContent';

        $binary = new Binary($originalContent, 'image/png', 'png');

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($expectedFilteredContent))
        ;

        $imagineMock = $this->createImagineMock();
        $imagineMock
            ->expects($this->once())
            ->method('load')
            ->with($originalContent)
            ->will($this->returnValue($image))
        ;

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $this->createFilterConfigurationMock(),

            $imagineMock,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $filteredBinary = $filterManager->apply($binary, array(
            'filters' => array(
                'thumbnail' => $thumbConfig,
            ),
            'post_processors' => array(),
        ));

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
        $this->assertEquals($expectedFilteredContent, $filteredBinary->getContent());
    }

    public function testReturnFilteredBinaryWithFormatOfOriginalBinaryOnApply()

    {
        $originalContent = 'aOriginalContent';
        $expectedFormat = 'png';

        $binary = new Binary($originalContent, 'image/png', $expectedFormat);

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue('aFilteredContent'))
        ;

        $imagineMock = $this->createImagineMock();
        $imagineMock
            ->expects($this->once())
            ->method('load')
            ->will($this->returnValue($image))
        ;

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $this->createFilterConfigurationMock(),

            $imagineMock,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $filteredBinary = $filterManager->apply($binary, array(
            'filters' => array(
                'thumbnail' => $thumbConfig,
            ),
            'post_processors' => array(),
        ));

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
        $this->assertEquals($expectedFormat, $filteredBinary->getFormat());
    }

    public function testReturnFilteredBinaryWithCustomFormatIfSetOnApply()

    {
        $originalContent = 'aOriginalContent';
        $originalFormat = 'png';
        $expectedFormat = 'jpg';

        $binary = new Binary($originalContent, 'image/png', $originalFormat);

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue('aFilteredContent'))
        ;

        $imagineMock = $this->createImagineMock();
        $imagineMock
            ->expects($this->once())
            ->method('load')
            ->will($this->returnValue($image))
        ;

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $this->createFilterConfigurationMock(),

            $imagineMock,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $filteredBinary = $filterManager->apply($binary, array(
            'format' => $expectedFormat,
            'filters' => array(
                'thumbnail' => $thumbConfig,
            ),
            'post_processors' => array(),
        ));

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
        $this->assertEquals($expectedFormat, $filteredBinary->getFormat());
    }

    public function testReturnFilteredBinaryWithMimeTypeOfOriginalBinaryOnApply()
    {
        $originalContent = 'aOriginalContent';
        $expectedMimeType = 'image/png';

        $binary = new Binary($originalContent, $expectedMimeType, 'png');

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue('aFilteredContent'))
        ;

        $imagineMock = $this->createImagineMock();
        $imagineMock
            ->expects($this->once())
            ->method('load')
            ->will($this->returnValue($image))
        ;

        $mimeTypeGuesser = $this->getMockMimeTypeGuesser();
        $mimeTypeGuesser
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->never())
            ->method('guess')
        ;

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $this->createFilterConfigurationMock(),

            $imagineMock,
            $mimeTypeGuesser
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $filteredBinary = $filterManager->apply($binary, array(
            'filters' => array(
                'thumbnail' => $thumbConfig,
            ),
            'post_processors' => array(),
        ));

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
        $this->assertEquals($expectedMimeType, $filteredBinary->getMimeType());
    }

    public function testReturnFilteredBinaryWithMimeTypeOfCustomFormatIfSetOnApply()
    {
        $originalContent = 'aOriginalContent';
        $originalMimeType = 'image/png';
        $expectedContent = 'aFilteredContent';
        $expectedMimeType = 'image/jpeg';

        $binary = new Binary($originalContent, $originalMimeType, 'png');

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($expectedContent))
        ;

        $imagineMock = $this->createImagineMock();
        $imagineMock
            ->expects($this->once())
            ->method('load')
            ->will($this->returnValue($image))
        ;

        $mimeTypeGuesser = $this->getMockMimeTypeGuesser();
        $mimeTypeGuesser
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('guess')
            ->with($expectedContent)
            ->will($this->returnValue($expectedMimeType))
        ;

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $this->createFilterConfigurationMock(),

            $imagineMock,
            $mimeTypeGuesser
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $filteredBinary = $filterManager->apply($binary, array(
            'format' => 'jpg',
            'filters' => array(
                'thumbnail' => $thumbConfig,
            ),
            'post_processors' => array(),
        ));

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
        $this->assertEquals($expectedMimeType, $filteredBinary->getMimeType());
    }

    public function testAltersQualityOnApply()

    {
        $originalContent = 'aOriginalContent';
        $expectedQuality = 80;

        $binary = new Binary($originalContent, 'image/png', 'png');

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->with('png', array('quality' => $expectedQuality))
            ->will($this->returnValue('aFilteredContent'))
        ;

        $imagineMock = $this->createImagineMock();
        $imagineMock
            ->expects($this->once())
            ->method('load')
            ->will($this->returnValue($image))
        ;

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $this->createFilterConfigurationMock(),

            $imagineMock,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $filteredBinary = $filterManager->apply($binary, array(
            'quality' => $expectedQuality,
            'filters' => array(
                'thumbnail' => $thumbConfig,
            ),
            'post_processors' => array(),
        ));

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
    }

    public function testAlters100QualityIfNotSetOnApply()

    {
        $originalContent = 'aOriginalContent';
        $expectedQuality = 100;

        $binary = new Binary($originalContent, 'image/png', 'png');

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->with('png', array('quality' => $expectedQuality))
            ->will($this->returnValue('aFilteredContent'))
        ;

        $imagineMock = $this->createImagineMock();
        $imagineMock
            ->expects($this->once())
            ->method('load')
            ->will($this->returnValue($image))
        ;

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $this->createFilterConfigurationMock(),

            $imagineMock,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $filteredBinary = $filterManager->apply($binary, array(
            'filters' => array(
                'thumbnail' => $thumbConfig,
            ),
            'post_processors' => array(),
        ));

        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
    }

    public function testApplyPostProcessor()
    {
        $originalContent = 'aContent';
        $expectedPostProcessedContent = 'postProcessedContent';
        $binary = new Binary($originalContent, 'image/png', 'png');

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $config = $this->createFilterConfigurationMock();
        $config
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->atLeastOnce())
            ->method('get')
            ->with('thumbnail')
            ->will($this->returnValue(array(
                'filters' => array(
                    'thumbnail' => $thumbConfig,
                ),
                'post_processors' => array(
                    'foo' => array(),
                ),
            )))
        ;

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($originalContent))
        ;

        $imagineMock = $this->createImagineMock();
        $imagineMock
            ->expects($this->once())
            ->method('load')
            ->with($originalContent)
            ->will($this->returnValue($image))
        ;

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $processedBinary = new Binary($expectedPostProcessedContent, 'image/png', 'png');

        $postProcessor = $this->getPostProcessorMock();
        $postProcessor
            ->expects($this->once())
            ->method('process')
            ->with($binary)
            ->will($this->returnValue($processedBinary));

        $filterManager = new FilterManager(
            $config,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $imagineMock,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $filterManager->addPostProcessor('foo', $postProcessor);

        $filteredBinary = $filterManager->applyFilter($binary, 'thumbnail');
        $this->assertInstanceOf('Liip\ImagineBundle\Model\Binary', $filteredBinary);
        $this->assertEquals($expectedPostProcessedContent, $filteredBinary->getContent());
    }

    public function testThrowsIfNoPostProcessorAddedForFilterOnApplyFilter()
    {
        $originalContent = 'aContent';
        $binary = new Binary($originalContent, 'image/png', 'png');

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $config = $this->createFilterConfigurationMock();
        $config
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->atLeastOnce())
            ->method('get')
            ->with('thumbnail')
            ->will($this->returnValue(array(
                'filters' => array(
                    'thumbnail' => $thumbConfig,
                ),
                'post_processors' => array(
                    'foo' => array(),
                ),
            )))
        ;

        $thumbConfig = array(
            'size' => array(180, 180),
            'mode' => 'outbound',
        );

        $image = $this->getMockImage();
        $image
            ->expects($this->once())
            ->method('get')
            ->will($this->returnValue($originalContent))
        ;

        $imagineMock = $this->createImagineMock();
        $imagineMock
            ->expects($this->once())
            ->method('load')
            ->with($originalContent)
            ->will($this->returnValue($image))
        ;

        $loader = $this->getMockLoader();
        $loader
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->expects($this->once())
            ->method('load')
            ->with($this->identicalTo($image), $thumbConfig)
            ->will($this->returnArgument(0))
        ;

        $filterManager = new FilterManager(
            $config,
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
            $imagineMock,
            $this->getMockMimeTypeGuesser()

        );
        $filterManager->addLoader('thumbnail', $loader);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->setExpectedException('InvalidArgumentException', 'Could not find post processor "foo"');

        $filterManager->applyFilter($binary, 'thumbnail');
    }

    public function testApplyPostProcessorsWhenNotDefined()
    {
        $binary = $this->getMock('Liip\ImagineBundle\Binary\BinaryInterface');
        $filterManager = new FilterManager(
            $this->createFilterConfigurationMock(),

            $this->createImagineMock(),
            $this->getMockMimeTypeGuesser()

        );

        $this->assertSame($binary, $filterManager->applyPostProcessors($binary, array()));
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|LoaderInterface
     */
    protected function getMockLoader()
    {
        return $this->getMock('Liip\ImagineBundle\Imagine\Filter\Loader\LoaderInterface');
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|\Liip\ImagineBundle\Binary\MimeTypeGuesserInterface
     */
    protected function getMockMimeTypeGuesser()
    {
        return $this->getMock('Liip\ImagineBundle\Binary\MimeTypeGuesserInterface');
    }

    protected function getPostProcessorMock()
    {
        return $this->getMock('Liip\ImagineBundle\Imagine\Filter\PostProcessor\PostProcessorInterface');
    }
}

Pull Request — master (#732)

testAlters100QualityIfNotSetOnApplyFilter() A

Complexity

Size

Duplication

How to fix Long Method

Long Method

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

1			<?php
2
3			namespace Liip\ImagineBundle\Tests\Filter;
4
5			use Liip\ImagineBundle\Imagine\Filter\FilterManager;
6			use Liip\ImagineBundle\Imagine\Filter\Loader\LoaderInterface;
7			use Liip\ImagineBundle\Model\Binary;
8			use Liip\ImagineBundle\Tests\AbstractTest;
9
10			/**
11			* @covers Liip\ImagineBundle\Imagine\Filter\FilterManager
12			*/
13			class FilterManagerTest extends AbstractTest
14			{
15			public function testThrowsIfNoLoadersAddedForFilterOnApplyFilter()
16			{
17			$config = $this->createFilterConfigurationMock();
18			$config
			0 ignored issues – show Bug introduced 2015-11-24 10:50 UTC by Report Bug Copy Issue Report The method `expects` does only exist in `PHPUnit_Framework_MockObject_MockObject`, but not in `Liip\ImagineBundle\Imagi...ter\FilterConfiguration`. It seems like the method you are trying to call exists only in some of the possible types. Let’s take a look at an example: class A { public function foo() { } } class B extends A { public function bar() { } } /** * @param A\|B $x / function someFunction($x) { $x->foo(); // This call is fine as the method exists in A and B. $x->bar(); // This method only exists in B and might cause an error. } Available Fixes Add an additional type-check: /* * @param A\|B $x / function someFunction($x) { $x->foo(); if ($x instanceof B) { $x->bar(); } } Only allow a single type to be passed if the variable comes from a parameter: function someFunction(B $x) { /* ... */ } Loading history...
19			->expects($this->atLeastOnce())
20			->method('get')
21			->with('thumbnail')
22			->will($this->returnValue(array(
23			'filters' => array(
24			'thumbnail' => array(
25			'size' => array(180, 180),
26			'mode' => 'outbound',
27			),
28			),
29			'post_processors' => array(),
30			)))
31			;
32
33			$binary = new Binary('aContent', 'image/png', 'png');
34
35			$filterManager = new FilterManager(
36			$config,
			0 ignored issues – show Bug introduced 2016-02-04 18:33 UTC by Report Bug Copy Issue Report It seems like `$config` defined by `$this->createFilterConfigurationMock()` on line `17` can also be of type `object<PHPUnit_Framework_MockObject_MockObject>`; however, `Liip\ImagineBundle\Imagi...rManager::__construct()` does only seem to accept `object<Liip\ImagineBundl...er\FilterConfiguration>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
37			$this->createImagineMock(),
38			$this->getMockMimeTypeGuesser()
liip / LiipImagineBundle

Pull Request — master (#732)

testAlters100QualityIfNotSetOnApplyFilter() A

Complexity

Size

Duplication

How to fix Long Method

Long Method

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
