GridExtensionTest::createPagerfantaMock() - Code Metrics - php-lug/lug - Measure and Improve Code Quality continuously with Scrutinizer

GridExtensionTest::createPagerfantaMock() A
last analyzed 2017-01-05 10:16 UTC

↳ Parent: GridExtensionTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
cc	1
eloc	2
nc	1
nop	0
<?php

/*
 * This file is part of the Lug package.
 *
 * (c) Eric GELOEN <[email protected]>
 *
 * For the full copyright and license information, please read the LICENSE
 * file that was distributed with this source code.
 */

namespace Lug\Bundle\GridBundle\Tests\Twig;

use Lug\Bundle\GridBundle\Twig\GridExtension;
use Lug\Component\Grid\Model\ActionInterface;
use Lug\Component\Grid\Model\ColumnInterface;
use Lug\Component\Grid\Renderer\RendererInterface;
use Lug\Component\Grid\View\GridViewInterface;
use Pagerfanta\Pagerfanta;
use WhiteOctober\PagerfantaBundle\Twig\PagerfantaExtension;

/**
 * @author GeLo <[email protected]>
 */
class GridExtensionTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var GridExtension
     */
    private $extension;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|RendererInterface
     */
    private $renderer;

    /**
     * @var \PHPUnit_Framework_MockObject_MockObject|PagerfantaExtension
     */
    private $pagerfantaExtension;

    /**
     * @var \Twig_Environment
     */
    private $twig;

    /**
     * {@inheritdoc}
     */
    protected function setUp()
    {
        $this->renderer = $this->createRendererMock();
        $this->pagerfantaExtension = $this->createPagerfantaExtensionMock();

        $this->extension = new GridExtension($this->renderer, $this->pagerfantaExtension);

        $this->twig = new \Twig_Environment(new \Twig_Loader_Array([]));
        $this->twig->addExtension($this->extension);
    }

    public function testInheritance()
    {
        $this->assertInstanceOf(RendererInterface::class, $this->extension);
        $this->assertInstanceOf(\Twig_Extension::class, $this->extension);
    }

    public function testGrid()
    {
        $this->renderer
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('render')
            ->with($this->identicalTo($grid = $this->createGridViewMock()))
            ->will($this->returnValue($result = '<div>result</div>'));

        $this->assertSame(
            $result,
            $this->twig->createTemplate('{{ lug_grid(grid) }}')->render(['grid' => $grid])
        );
    }

    public function testFilters()
    {
        $this->renderer
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('renderFilters')
            ->with($this->identicalTo($grid = $this->createGridViewMock()))
            ->will($this->returnValue($result = '<div>result</div>'));

        $this->assertSame(
            $result,
            $this->twig->createTemplate('{{ lug_grid_filters(grid) }}')->render(['grid' => $grid])
        );
    }

    public function testBody()
    {
        $this->renderer
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('renderGrid')
            ->with($this->identicalTo($grid = $this->createGridViewMock()))
            ->will($this->returnValue($result = '<div>result</div>'));

        $this->assertSame(
            $result,
            $this->twig->createTemplate('{{ lug_grid_body(grid) }}')->render(['grid' => $grid])
        );
    }

    public function testColumn()

    {
        $this->renderer
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('renderColumn')
            ->with(
                $this->identicalTo($grid = $this->createGridViewMock()),
                $this->identicalTo($column = $this->createColumnMock()),
                $this->identicalTo($data = 'data')
            )
            ->will($this->returnValue($result = '<div>result</div>'));

        $this->assertSame(
            $result,
            $this->twig
                ->createTemplate('{{ lug_grid_column(grid, column, data) }}')
                ->render(['grid' => $grid, 'column' => $column, 'data' => $data])
        );
    }

    public function testColumnActions()
    {
        $this->renderer
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('renderColumnActions')
            ->with(
                $this->identicalTo($grid = $this->createGridViewMock()),
                $this->identicalTo($data = 'data')
            )
            ->will($this->returnValue($result = '<div>result</div>'));

        $this->assertSame(
            $result,
            $this->twig
                ->createTemplate('{{ lug_grid_column_actions(grid, data) }}')
                ->render(['grid' => $grid, 'data' => $data])
        );
    }

    public function testColumnAction()

    {
        $this->renderer
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('renderColumnAction')
            ->with(
                $this->identicalTo($grid = $this->createGridViewMock()),
                $this->identicalTo($action = $this->createActionMock()),
                $this->identicalTo($data = 'data')
            )
            ->will($this->returnValue($result = '<div>result</div>'));

        $this->assertSame(
            $result,
            $this->twig
                ->createTemplate('{{ lug_grid_column_action(grid, action, data) }}')
                ->render(['grid' => $grid, 'action' => $action, 'data' => $data])
        );
    }

    public function testColumnSortings()
    {
        $this->renderer
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('renderColumnSortings')
            ->with(
                $this->identicalTo($grid = $this->createGridViewMock()),
                $this->identicalTo($column = $this->createColumnMock())
            )
            ->will($this->returnValue($result = '<div>result</div>'));

        $this->assertSame(
            $result,
            $this->twig
                ->createTemplate('{{ lug_grid_column_sortings(grid, column) }}')
                ->render(['grid' => $grid, 'column' => $column])
        );
    }

    public function testColumnSorting()

    {
        $this->renderer
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('renderColumnSorting')
            ->with(
                $this->identicalTo($grid = $this->createGridViewMock()),
                $this->identicalTo($column = $this->createColumnMock()),
                $this->identicalTo($sorting = 'sorting')
            )
            ->will($this->returnValue($result = '<div>result</div>'));

        $this->assertSame(
            $result,
            $this->twig
                ->createTemplate('{{ lug_grid_column_sorting(grid, column, sorting) }}')
                ->render(['grid' => $grid, 'column' => $column, 'sorting' => $sorting])
        );
    }

    public function testGlobalActions()
    {
        $this->renderer
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('renderGlobalActions')
            ->with($this->identicalTo($grid = $this->createGridViewMock()))
            ->will($this->returnValue($result = '<div>result</div>'));

        $this->assertSame(
            $result,
            $this->twig->createTemplate('{{ lug_grid_global_actions(grid) }}')->render(['grid' => $grid])
        );
    }

    public function testGlobalAction()
    {
        $this->renderer
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('renderGlobalAction')
            ->with(
                $this->identicalTo($grid = $this->createGridViewMock()),
                $this->identicalTo($action = $this->createActionMock())
            )
            ->will($this->returnValue($result = '<div>result</div>'));

        $this->assertSame(
            $result,
            $this->twig
                ->createTemplate('{{ lug_grid_global_action(grid, action) }}')
                ->render(['grid' => $grid, 'action' => $action])
        );
    }

    public function testPager()

    {
        $this->pagerfantaExtension
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('renderPagerfanta')
            ->with(
                $this->identicalTo($pager = $this->createPagerfantaMock()),
                $this->identicalTo($name = 'name'),
                $this->identicalTo($options = ['foo' => 'bar'])
            )
            ->will($this->returnValue($result = '<div>result</div>'));

        $this->assertSame(
            $result,
            $this->twig
                ->createTemplate('{{ lug_grid_pager(pager, name, options) }}')
                ->render(['pager' => $pager, 'name' => $name, 'options' => $options])
        );
    }

    public function testPagerWithReset()
    {
        $this->pagerfantaExtension
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('renderPagerfanta')
            ->with(
                $this->identicalTo($pager = $this->createPagerfantaMock()),
                $this->identicalTo($name = 'name'),
                $this->identicalTo($options = ['routeParams' => ['foo' => 'bar']])
            )
            ->will($this->returnValue($result = '<div>result</div>'));

        $options['routeParams']['grid']['baz'] = 'bat';
        $options['routeParams']['grid']['reset'] = true;

        $this->assertSame(
            $result,
            $this->twig
                ->createTemplate('{{ lug_grid_pager(pager, name, options) }}')
                ->render(['pager' => $pager, 'name' => $name, 'options' => $options])
        );
    }

    public function testName()
    {
        $this->assertSame('lug_grid', $this->extension->getName());
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|RendererInterface
     */
    private function createRendererMock()
    {
        return $this->createMock(RendererInterface::class);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|PagerfantaExtension
     */
    private function createPagerfantaExtensionMock()
    {
        return $this->createMock(PagerfantaExtension::class);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|GridViewInterface
     */
    private function createGridViewMock()
    {
        return $this->createMock(GridViewInterface::class);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|ColumnInterface
     */
    private function createColumnMock()
    {
        return $this->createMock(ColumnInterface::class);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|ActionInterface
     */
    private function createActionMock()
    {
        return $this->createMock(ActionInterface::class);
    }

    /**
     * @return \PHPUnit_Framework_MockObject_MockObject|Pagerfanta
     */
    private function createPagerfantaMock()
    {
        return $this->createMock(Pagerfanta::class);
    }
}

GridExtensionTest::createPagerfantaMock() A
last analyzed 2017-01-05 10:16 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

php-lug / lug

GridExtensionTest::createPagerfantaMock() A last analyzed 2017-01-05 10:16 UTC

Complexity

Size

Duplication

Importance

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

GridExtensionTest::createPagerfantaMock() A
last analyzed 2017-01-05 10:16 UTC
