Issues in PagerTest.php - All Issues - Inspection of "Add existence check for _delete field" - sonata-project/SonataAdminBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 3.x ( e95e95...638cd1 )

by Oskar

created 2019-06-26 10:13 UTC

tests/Datagrid/PagerTest.php (1 issue)

Labels

Bug 1

Severity

Major 1

Sullivan SENECHAL 1

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?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\AdminBundle\Tests\Datagrid;

use PHPUnit\Framework\TestCase;
use Sonata\AdminBundle\Datagrid\Pager;
use Sonata\AdminBundle\Datagrid\ProxyQueryInterface;

/**
 * @author Andrej Hudec <[email protected]>
 */
class PagerTest extends TestCase
{
    /**
     * @var Pager
     */
    private $pager;

    protected function setUp(): void
    {
        $this->pager = $this->getMockForAbstractClass(Pager::class);
    }

    /**
     * @dataProvider getGetMaxPerPage1Tests
     */
    public function testGetMaxPerPage1($expectedMaxPerPage, $expectedPage, $maxPerPage, $page): void
    {
        $this->assertSame(10, $this->pager->getMaxPerPage());
        $this->assertSame(1, $this->pager->getPage());

        if (null !== $page) {
            $this->pager->setPage($page);
        }

        $this->pager->setMaxPerPage($maxPerPage);

        $this->assertSame($expectedPage, $this->pager->getPage());
        $this->assertSame($expectedMaxPerPage, $this->pager->getMaxPerPage());
    }

    public function getGetMaxPerPage1Tests()
    {
        return [
            [123, 1, 123, 1],
            [123, 321, 123, 321],
            [1, 1, 1, 0],
            [0, 0, 0, 0],
            [1, 1, -1, 1],
            [1, 1, -1, 0],
            [1, 1, -1, -1],
            [0, 0, 0, null],
        ];
    }

    public function testGetMaxPerPage2(): void
    {
        $this->assertSame(10, $this->pager->getMaxPerPage());
        $this->assertSame(1, $this->pager->getPage());

        $this->pager->setMaxPerPage(0);
        $this->pager->setPage(0);

        $this->assertSame(0, $this->pager->getMaxPerPage());
        $this->assertSame(0, $this->pager->getPage());

        $this->pager->setMaxPerPage(12);

        $this->assertSame(12, $this->pager->getMaxPerPage());
        $this->assertSame(1, $this->pager->getPage());
    }

    public function testGetMaxPerPage3(): void
    {
        $this->assertSame(10, $this->pager->getMaxPerPage());
        $this->assertSame(1, $this->pager->getPage());

        $this->pager->setMaxPerPage(0);

        $this->assertSame(0, $this->pager->getMaxPerPage());
        $this->assertSame(0, $this->pager->getPage());

        $this->pager->setMaxPerPage(-1);

        $this->assertSame(1, $this->pager->getMaxPerPage());
        $this->assertSame(1, $this->pager->getPage());
    }

    public function testGetCurrentMaxLink(): void
    {
        $this->assertSame(1, $this->pager->getCurrentMaxLink());

        $this->pager->getLinks();
        $this->assertSame(1, $this->pager->getCurrentMaxLink());

        $this->callMethod($this->pager, 'setLastPage', [20]);
        $this->pager->getLinks(10);
        $this->assertSame(10, $this->pager->getCurrentMaxLink());

        $this->pager->setMaxPageLinks(5);
        $this->pager->setPage(2);
        $this->assertSame(10, $this->pager->getCurrentMaxLink());
    }

    public function testGetMaxRecordLimit(): void
    {
        $this->assertFalse($this->pager->getMaxRecordLimit());

        $this->pager->setMaxRecordLimit(99);
        $this->assertSame(99, $this->pager->getMaxRecordLimit());
    }

    public function testGetNbResults(): void
    {
        $this->assertSame(0, $this->pager->getNbResults());

        $this->callMethod($this->pager, 'setNbResults', [100]);

        $this->assertSame(100, $this->pager->getNbResults());
    }

    public function testCount(): void
    {
        $this->assertSame(0, $this->pager->count());

        $this->callMethod($this->pager, 'setNbResults', [100]);

        $this->assertSame(100, $this->pager->count());
    }

    public function testGetQuery(): void
    {
        $query = $this->createMock(ProxyQueryInterface::class);

        $this->pager->setQuery($query);
        $this->assertSame($query, $this->pager->getQuery());
    }

    public function testGetCountColumn(): void
    {
        $this->assertSame(['id'], $this->pager->getCountColumn());

        $this->pager->setCountColumn(['foo']);
        $this->assertSame(['foo'], $this->pager->getCountColumn());
    }

    public function testParameters(): void
    {
        $this->assertNull($this->pager->getParameter('foo', null));
        $this->assertSame('bar', $this->pager->getParameter('foo', 'bar'));
        $this->assertFalse($this->pager->hasParameter('foo'));
        $this->assertSame([], $this->pager->getParameters());

        $this->pager->setParameter('foo', 'foo_value');

        $this->assertTrue($this->pager->hasParameter('foo'));
        $this->assertSame('foo_value', $this->pager->getParameter('foo', null));
        $this->assertSame('foo_value', $this->pager->getParameter('foo', 'bar'));
        $this->assertSame(['foo' => 'foo_value'], $this->pager->getParameters());

        $this->pager->setParameter('foo', 'baz');

        $this->assertTrue($this->pager->hasParameter('foo'));
        $this->assertSame('baz', $this->pager->getParameter('foo', null));
        $this->assertSame('baz', $this->pager->getParameter('foo', 'bar'));
        $this->assertSame(['foo' => 'baz'], $this->pager->getParameters());

        $this->pager->setParameter('foo2', 'foo2_value');

        $this->assertTrue($this->pager->hasParameter('foo2'));
        $this->assertSame('foo2_value', $this->pager->getParameter('foo2', null));
        $this->assertSame('foo2_value', $this->pager->getParameter('foo2', 'bar'));
        $this->assertSame(['foo' => 'baz', 'foo2' => 'foo2_value'], $this->pager->getParameters());
    }

    public function testGetMaxPageLinks(): void
    {
        $this->assertSame(0, $this->pager->getMaxPageLinks());

        $this->pager->setMaxPageLinks(123);
        $this->assertSame(123, $this->pager->getMaxPageLinks());
    }

    public function testIsFirstPage(): void
    {
        $this->assertTrue($this->pager->isFirstPage());

        $this->pager->setPage(123);
        $this->assertFalse($this->pager->isFirstPage());
    }

    public function testIsLastPage(): void
    {
        $this->assertTrue($this->pager->isLastPage());
        $this->assertSame(1, $this->pager->getLastPage());

        $this->pager->setPage(10);
        $this->callMethod($this->pager, 'setLastPage', [50]);
        $this->assertSame(50, $this->pager->getLastPage());
        $this->assertFalse($this->pager->isLastPage());

        $this->pager->setPage(50);
        $this->assertTrue($this->pager->isLastPage());

        $this->callMethod($this->pager, 'setLastPage', [20]);
        $this->assertSame(20, $this->pager->getPage());
        $this->assertSame(20, $this->pager->getLastPage());
        $this->assertTrue($this->pager->isLastPage());
    }

    public function testGetLinks(): void
    {
        $this->assertSame([], $this->pager->getLinks());

        $this->pager->setPage(1);
        $this->pager->setMaxPageLinks(1);
        $this->assertSame([1], $this->pager->getLinks());
        $this->assertSame([1], $this->pager->getLinks(10));

        $this->pager->setPage(1);
        $this->pager->setMaxPageLinks(7);
        $this->callMethod($this->pager, 'setLastPage', [50]);
        $this->assertCount(7, $this->pager->getLinks());
        $this->assertSame([1, 2, 3, 4, 5, 6, 7], $this->pager->getLinks());

        $this->pager->setPage(10);
        $this->pager->setMaxPageLinks(12);
        $this->assertCount(5, $this->pager->getLinks(5));
        $this->assertSame([8, 9, 10, 11, 12], $this->pager->getLinks(5));

        $this->pager->setPage(10);
        $this->pager->setMaxPageLinks(6);
        $this->assertCount(6, $this->pager->getLinks());
        $this->assertSame([7, 8, 9, 10, 11, 12], $this->pager->getLinks());

        $this->pager->setPage(50);
        $this->pager->setMaxPageLinks(6);
        $this->assertCount(6, $this->pager->getLinks());
        $this->assertSame([45, 46, 47, 48, 49, 50], $this->pager->getLinks());
    }

    public function testHaveToPaginate(): void
    {
        $this->assertFalse($this->pager->haveToPaginate());

        $this->pager->setMaxPerPage(10);
        $this->assertFalse($this->pager->haveToPaginate());

        $this->callMethod($this->pager, 'setNbResults', [100]);
        $this->assertTrue($this->pager->haveToPaginate());
    }

    public function testIterator(): void
    {
        $this->assertTrue($this->pager instanceof \Iterator);

        $object1 = new \stdClass();
        $object1->foo = 'bar1';

        $object2 = new \stdClass();
        $object2->foo = 'bar2';

        $object3 = new \stdClass();
        $object3->foo = 'bar3';

        $expectedObjects = [$object1, $object2, $object3];

        $this->pager->expects($this->any())
            ->method('getResults')
            ->willReturn($expectedObjects);

        $counter = 0;
        $values = [];
        foreach ($this->pager as $key => $value) {
            $values[$key] = $value;
            ++$counter;
        }

        $this->assertSame(3, $counter);
        $this->assertSame($object3, $value);
foreach ($a as $b) {
}

// $b is defined here only if $a has elements, for example if $a is array()
// then $b would not be defined here. To avoid that, we recommend to set a
// default value for $b.


// Better
$b = 0; // or whatever default makes sense in your context
foreach ($a as $b) {
}

// $b is now guaranteed to be defined here.
        $this->assertSame($expectedObjects, $values);

        $this->assertFalse($this->pager->valid());

        $this->callMethod($this->pager, 'resetIterator');
        $this->assertTrue($this->pager->valid());
    }

    public function testValid(): void
    {
        $this->pager->expects($this->any())
            ->method('getResults')
            ->willReturn([]);

        $this->assertFalse($this->pager->valid());
    }

    public function testNext(): void
    {
        $this->pager->expects($this->any())
            ->method('getResults')
            ->willReturn([]);

        $this->assertFalse($this->pager->next());
    }

    public function testKey(): void
    {
        $this->pager->expects($this->any())
            ->method('getResults')
            ->willReturn([123 => new \stdClass()]);

        $this->assertSame(123, $this->pager->key());
    }

    public function testCurrent(): void
    {
        $object = new \stdClass();

        $this->pager->expects($this->any())
            ->method('getResults')
            ->willReturn([$object]);

        $this->assertSame($object, $this->pager->current());
    }

    public function testGetCursor(): void
    {
        $this->assertSame(1, $this->pager->getCursor());

        $this->pager->setCursor(0);
        $this->assertSame(1, $this->pager->getCursor());

        $this->pager->setCursor(300);
        $this->assertSame(0, $this->pager->getCursor());

        $this->callMethod($this->pager, 'setNbResults', [100]);

        $this->pager->setCursor(5);
        $this->assertSame(5, $this->pager->getCursor());

        $this->pager->setCursor(300);
        $this->assertSame(100, $this->pager->getCursor());
    }

    public function testGetObjectByCursor(): void
    {
        $object1 = new \stdClass();
        $object1->foo = 'bar1';

        $object2 = new \stdClass();
        $object2->foo = 'bar2';

        $object3 = new \stdClass();
        $object3->foo = 'bar3';

        $this->callMethod($this->pager, 'setNbResults', [3]);

        $query = $this->createMock(ProxyQueryInterface::class);

        $query->expects($this->any())
            ->method('setFirstResult')
            ->willReturn($query);

        $query->expects($this->any())
            ->method('setMaxResults')
            ->willReturn($query);

        $id = 0;
        $query->expects($this->any())
            ->method('execute')
            ->willReturnCallback(static function () use (&$id, $object1, $object2, $object3) {
                switch ($id) {
                    case 0:
                        return [$object1];

                    case 1:
                        return [$object2];

                    case 2:
                        return [$object3];
                }
            });

        $this->pager->setQuery($query);

        $this->assertSame($object1, $this->pager->getObjectByCursor(1));
        $this->assertSame(1, $this->pager->getCursor());

        $id = 1;
        $this->assertSame($object2, $this->pager->getObjectByCursor(2));
        $this->assertSame(2, $this->pager->getCursor());

        $id = 2;
        $this->assertSame($object3, $this->pager->getObjectByCursor(3));
        $this->assertSame(3, $this->pager->getCursor());

        $id = 3;
        $this->assertNull($this->pager->getObjectByCursor(4));
        $this->assertSame(3, $this->pager->getCursor());
    }

    public function testGetFirstPage(): void
    {
        $this->assertSame(1, $this->pager->getFirstPage());
    }

    public function testGetNextPage(): void
    {
        $this->assertSame(1, $this->pager->getNextPage());

        $this->pager->setPage(3);
        $this->callMethod($this->pager, 'setLastPage', [20]);
        $this->assertSame(4, $this->pager->getNextPage());

        $this->pager->setPage(21);
        $this->assertSame(20, $this->pager->getNextPage());
    }

    public function testGetPreviousPage(): void
    {
        $this->assertSame(1, $this->pager->getPreviousPage());

        $this->pager->setPage(3);
        $this->assertSame(2, $this->pager->getPreviousPage());

        $this->pager->setPage(21);
        $this->assertSame(20, $this->pager->getPreviousPage());
    }

    public function testGetFirstIndex(): void
    {
        $this->assertSame(1, $this->pager->getFirstIndex());

        $this->pager->setMaxPerPage(0);
        $this->pager->setPage(0);
        $this->assertSame(1, $this->pager->getFirstIndex());

        $this->pager->setPage(2);
        $this->pager->setMaxPerPage(10);
        $this->assertSame(11, $this->pager->getFirstIndex());

        $this->pager->setPage(4);
        $this->pager->setMaxPerPage(7);
        $this->assertSame(22, $this->pager->getFirstIndex());
    }

    public function testGetLastIndex(): void
    {
        $this->assertSame(0, $this->pager->getLastIndex());

        $this->pager->setMaxPerPage(0);
        $this->pager->setPage(0);
        $this->assertSame(0, $this->pager->getLastIndex());

        $this->callMethod($this->pager, 'setNbResults', [100]);

        $this->assertSame(100, $this->pager->getLastIndex());

        $this->pager->setPage(2);
        $this->assertSame(0, $this->pager->getLastIndex());

        $this->pager->setMaxPerPage(10);
        $this->assertSame(20, $this->pager->getLastIndex());

        $this->pager->setPage(11);
        $this->assertSame(100, $this->pager->getLastIndex());
    }

    public function testGetNext(): void
    {
        $this->assertNull($this->pager->getNext());

        $object1 = new \stdClass();
        $object1->foo = 'bar1';

        $object2 = new \stdClass();
        $object2->foo = 'bar2';

        $object3 = new \stdClass();
        $object3->foo = 'bar3';

        $this->callMethod($this->pager, 'setNbResults', [3]);

        $query = $this->createMock(ProxyQueryInterface::class);

        $query->expects($this->any())
            ->method('setFirstResult')
            ->willReturn($query);

        $query->expects($this->any())
            ->method('setMaxResults')
            ->willReturn($query);

        $id = 0;
        $query->expects($this->any())
            ->method('execute')
            ->willReturnCallback(static function () use (&$id, $object1, $object2, $object3) {
                switch ($id) {
                    case 0:
                        return [$object1];

                    case 1:
                        return [$object2];

                    case 2:
                        return [$object3];
                }
            });

        $this->pager->setQuery($query);

        $this->pager->setCursor(1);
        $this->assertSame($object1, $this->pager->getCurrent());

        ++$id;
        $this->assertSame($object2, $this->pager->getNext());

        ++$id;
        $this->assertSame($object3, $this->pager->getNext());

        ++$id;
        $this->assertNull($this->pager->getNext());
    }

    public function testGetPrevious(): void
    {
        $this->assertNull($this->pager->getPrevious());

        $object1 = new \stdClass();
        $object1->foo = 'bar1';

        $object2 = new \stdClass();
        $object2->foo = 'bar2';

        $object3 = new \stdClass();
        $object3->foo = 'bar3';

        $this->callMethod($this->pager, 'setNbResults', [3]);

        $query = $this->createMock(ProxyQueryInterface::class);

        $query->expects($this->any())
            ->method('setFirstResult')
            ->willReturn($query);

        $query->expects($this->any())
            ->method('setMaxResults')
            ->willReturn($query);

        $id = 2;
        $query->expects($this->any())
            ->method('execute')
            ->willReturnCallback(static function () use (&$id, $object1, $object2, $object3) {
                switch ($id) {
                    case 0:
                        return [$object1];

                    case 1:
                        return [$object2];

                    case 2:
                        return [$object3];
                }
            });

        $this->pager->setQuery($query);

        $this->pager->setCursor(2);
        $this->assertSame($object3, $this->pager->getCurrent());

        --$id;
        $this->assertSame($object2, $this->pager->getPrevious());

        --$id;
        $this->assertSame($object1, $this->pager->getPrevious());

        --$id;
        $this->assertNull($this->pager->getPrevious());
    }

    public function testSerialize(): void
    {
        $pagerClone = clone $this->pager;
        $data = $this->pager->serialize();
        $this->assertNotEmpty($data);

        $this->pager->setPage(12);
        $this->pager->setMaxPerPage(4);
        $this->pager->setMaxPageLinks(6);

        $this->pager->unserialize($data);
        $this->assertSame($pagerClone->getPage(), $this->pager->getPage());
        $this->assertSame($pagerClone->getMaxPerPage(), $this->pager->getMaxPerPage());
        $this->assertSame($pagerClone->getMaxPageLinks(), $this->pager->getMaxPageLinks());
    }

    public function testUnserialize(): void
    {
        $serialized = [
            'page' => 6,
            'maxPerPage' => 7,
            'maxPageLinks' => 5,
            'lastPage' => 4,
            'nbResults' => 30,
            'cursor' => 3,
            'parameters' => ['foo' => 'bar'],
            'currentMaxLink' => 2,
            'maxRecordLimit' => 22,
            'countColumn' => ['idx'],
        ];

        $this->pager->expects($this->any())
            ->method('getResults')
            ->willReturn([]);
        $this->pager->current();

        $this->pager->unserialize(serialize($serialized));

        $this->assertSame(7, $this->pager->getMaxPerPage());
        $this->assertSame(6, $this->pager->getPage());
        $this->assertSame(5, $this->pager->getMaxPageLinks());
        $this->assertSame(4, $this->pager->getLastPage());
        $this->assertSame(['idx'], $this->pager->getCountColumn());
        $this->assertSame(30, $this->pager->getNbResults());
        $this->assertSame(3, $this->pager->getCursor());
        $this->assertSame(['foo' => 'bar'], $this->pager->getParameters());
        $this->assertSame(2, $this->pager->getCurrentMaxLink());
        $this->assertSame(22, $this->pager->getMaxRecordLimit());
        $this->assertNull($this->pager->getQuery());
    }

    protected function callMethod($obj, $name, array $args = [])
    {
        $class = new \ReflectionClass($obj);
        $method = $class->getMethod($name);
        $method->setAccessible(true);

        return $method->invokeArgs($obj, $args);
    }
}


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\AdminBundle\Tests\Datagrid;
15
16			use PHPUnit\Framework\TestCase;
17			use Sonata\AdminBundle\Datagrid\Pager;
18			use Sonata\AdminBundle\Datagrid\ProxyQueryInterface;
19
20			/**
21			* @author Andrej Hudec <[email protected]>
22			*/
23			class PagerTest extends TestCase
24			{
25			/**
26			* @var Pager
27			*/
28			private $pager;
29
30			protected function setUp(): void
31			{
32			$this->pager = $this->getMockForAbstractClass(Pager::class);
33			}
34
35			/**
36			* @dataProvider getGetMaxPerPage1Tests
37			*/
38			public function testGetMaxPerPage1($expectedMaxPerPage, $expectedPage, $maxPerPage, $page): void
39			{
40			$this->assertSame(10, $this->pager->getMaxPerPage());
41			$this->assertSame(1, $this->pager->getPage());
42
43			if (null !== $page) {
44			$this->pager->setPage($page);
45			}
46
47			$this->pager->setMaxPerPage($maxPerPage);
48
49			$this->assertSame($expectedPage, $this->pager->getPage());
50			$this->assertSame($expectedMaxPerPage, $this->pager->getMaxPerPage());
51			}
52
53			public function getGetMaxPerPage1Tests()
54			{
55			return [
56			[123, 1, 123, 1],
57			[123, 321, 123, 321],
58			[1, 1, 1, 0],
59			[0, 0, 0, 0],
60			[1, 1, -1, 1],
61			[1, 1, -1, 0],
62			[1, 1, -1, -1],
63			[0, 0, 0, null],
64			];
65			}
66
67			public function testGetMaxPerPage2(): void
68			{
69			$this->assertSame(10, $this->pager->getMaxPerPage());
70			$this->assertSame(1, $this->pager->getPage());
71
72			$this->pager->setMaxPerPage(0);
73			$this->pager->setPage(0);
74
75			$this->assertSame(0, $this->pager->getMaxPerPage());
76			$this->assertSame(0, $this->pager->getPage());
77
78			$this->pager->setMaxPerPage(12);
79
80			$this->assertSame(12, $this->pager->getMaxPerPage());
81			$this->assertSame(1, $this->pager->getPage());
82			}
83
84			public function testGetMaxPerPage3(): void
85			{
86			$this->assertSame(10, $this->pager->getMaxPerPage());
87			$this->assertSame(1, $this->pager->getPage());
88
89			$this->pager->setMaxPerPage(0);
90
91			$this->assertSame(0, $this->pager->getMaxPerPage());
92			$this->assertSame(0, $this->pager->getPage());
93
94			$this->pager->setMaxPerPage(-1);
95
96			$this->assertSame(1, $this->pager->getMaxPerPage());
97			$this->assertSame(1, $this->pager->getPage());
98			}
99
100			public function testGetCurrentMaxLink(): void
101			{
102			$this->assertSame(1, $this->pager->getCurrentMaxLink());
103
104			$this->pager->getLinks();
105			$this->assertSame(1, $this->pager->getCurrentMaxLink());
106
107			$this->callMethod($this->pager, 'setLastPage', [20]);
108			$this->pager->getLinks(10);
109			$this->assertSame(10, $this->pager->getCurrentMaxLink());
110
111			$this->pager->setMaxPageLinks(5);
112			$this->pager->setPage(2);
113			$this->assertSame(10, $this->pager->getCurrentMaxLink());
114			}
115
116			public function testGetMaxRecordLimit(): void
117			{
118			$this->assertFalse($this->pager->getMaxRecordLimit());
119
120			$this->pager->setMaxRecordLimit(99);
121			$this->assertSame(99, $this->pager->getMaxRecordLimit());
122			}
123
124			public function testGetNbResults(): void
125			{
126			$this->assertSame(0, $this->pager->getNbResults());
127
128			$this->callMethod($this->pager, 'setNbResults', [100]);
129
130			$this->assertSame(100, $this->pager->getNbResults());
131			}
132
133			public function testCount(): void
134			{
135			$this->assertSame(0, $this->pager->count());
136
137			$this->callMethod($this->pager, 'setNbResults', [100]);
138
139			$this->assertSame(100, $this->pager->count());
140			}
141
142			public function testGetQuery(): void
143			{
144			$query = $this->createMock(ProxyQueryInterface::class);
145
146			$this->pager->setQuery($query);
147			$this->assertSame($query, $this->pager->getQuery());
148			}
149
150			public function testGetCountColumn(): void
151			{
152			$this->assertSame(['id'], $this->pager->getCountColumn());
153
154			$this->pager->setCountColumn(['foo']);
155			$this->assertSame(['foo'], $this->pager->getCountColumn());
156			}
157
158			public function testParameters(): void
159			{
160			$this->assertNull($this->pager->getParameter('foo', null));
161			$this->assertSame('bar', $this->pager->getParameter('foo', 'bar'));
162			$this->assertFalse($this->pager->hasParameter('foo'));
163			$this->assertSame([], $this->pager->getParameters());
164
165			$this->pager->setParameter('foo', 'foo_value');
166
167			$this->assertTrue($this->pager->hasParameter('foo'));
168			$this->assertSame('foo_value', $this->pager->getParameter('foo', null));
169			$this->assertSame('foo_value', $this->pager->getParameter('foo', 'bar'));
170			$this->assertSame(['foo' => 'foo_value'], $this->pager->getParameters());
171
172			$this->pager->setParameter('foo', 'baz');
173
174			$this->assertTrue($this->pager->hasParameter('foo'));
175			$this->assertSame('baz', $this->pager->getParameter('foo', null));
176			$this->assertSame('baz', $this->pager->getParameter('foo', 'bar'));
177			$this->assertSame(['foo' => 'baz'], $this->pager->getParameters());
178
179			$this->pager->setParameter('foo2', 'foo2_value');
180
181			$this->assertTrue($this->pager->hasParameter('foo2'));
182			$this->assertSame('foo2_value', $this->pager->getParameter('foo2', null));
183			$this->assertSame('foo2_value', $this->pager->getParameter('foo2', 'bar'));
184			$this->assertSame(['foo' => 'baz', 'foo2' => 'foo2_value'], $this->pager->getParameters());
185			}
186
187			public function testGetMaxPageLinks(): void
188			{
189			$this->assertSame(0, $this->pager->getMaxPageLinks());
190
191			$this->pager->setMaxPageLinks(123);
192			$this->assertSame(123, $this->pager->getMaxPageLinks());
193			}
194
195			public function testIsFirstPage(): void
196			{
197			$this->assertTrue($this->pager->isFirstPage());
198
199			$this->pager->setPage(123);
200			$this->assertFalse($this->pager->isFirstPage());
201			}
202
203			public function testIsLastPage(): void
204			{
205			$this->assertTrue($this->pager->isLastPage());
206			$this->assertSame(1, $this->pager->getLastPage());
207
208			$this->pager->setPage(10);
209			$this->callMethod($this->pager, 'setLastPage', [50]);
210			$this->assertSame(50, $this->pager->getLastPage());
211			$this->assertFalse($this->pager->isLastPage());
212
213			$this->pager->setPage(50);
214			$this->assertTrue($this->pager->isLastPage());
215
216			$this->callMethod($this->pager, 'setLastPage', [20]);
217			$this->assertSame(20, $this->pager->getPage());
218			$this->assertSame(20, $this->pager->getLastPage());
219			$this->assertTrue($this->pager->isLastPage());
220			}
221
222			public function testGetLinks(): void
223			{
224			$this->assertSame([], $this->pager->getLinks());
225
226			$this->pager->setPage(1);
227			$this->pager->setMaxPageLinks(1);
228			$this->assertSame([1], $this->pager->getLinks());
229			$this->assertSame([1], $this->pager->getLinks(10));
230
231			$this->pager->setPage(1);
232			$this->pager->setMaxPageLinks(7);
233			$this->callMethod($this->pager, 'setLastPage', [50]);
234			$this->assertCount(7, $this->pager->getLinks());
235			$this->assertSame([1, 2, 3, 4, 5, 6, 7], $this->pager->getLinks());
236
237			$this->pager->setPage(10);
238			$this->pager->setMaxPageLinks(12);
239			$this->assertCount(5, $this->pager->getLinks(5));
240			$this->assertSame([8, 9, 10, 11, 12], $this->pager->getLinks(5));
241
242			$this->pager->setPage(10);
243			$this->pager->setMaxPageLinks(6);
244			$this->assertCount(6, $this->pager->getLinks());
245			$this->assertSame([7, 8, 9, 10, 11, 12], $this->pager->getLinks());
246
247			$this->pager->setPage(50);
248			$this->pager->setMaxPageLinks(6);
249			$this->assertCount(6, $this->pager->getLinks());
250			$this->assertSame([45, 46, 47, 48, 49, 50], $this->pager->getLinks());
251			}
252
253			public function testHaveToPaginate(): void
254			{
255			$this->assertFalse($this->pager->haveToPaginate());
256
257			$this->pager->setMaxPerPage(10);
258			$this->assertFalse($this->pager->haveToPaginate());
259
260			$this->callMethod($this->pager, 'setNbResults', [100]);
261			$this->assertTrue($this->pager->haveToPaginate());
262			}
263
264			public function testIterator(): void
265			{
266			$this->assertTrue($this->pager instanceof \Iterator);
267
268			$object1 = new \stdClass();
269			$object1->foo = 'bar1';
270
271			$object2 = new \stdClass();
272			$object2->foo = 'bar2';
273
274			$object3 = new \stdClass();
275			$object3->foo = 'bar3';
276
277			$expectedObjects = [$object1, $object2, $object3];
278
279			$this->pager->expects($this->any())
280			->method('getResults')
281			->willReturn($expectedObjects);
282
283			$counter = 0;
284			$values = [];
285			foreach ($this->pager as $key => $value) {
286			$values[$key] = $value;
287			++$counter;
288			}
289
290			$this->assertSame(3, $counter);
291			$this->assertSame($object3, $value);
			0 ignored issues – show Bug introduced 2017-05-15 14:24 UTC by Report Bug Copy Issue Report Show Similar Issues like this The variable `$value` seems to be defined by a `foreach` iteration on line `285`. Are you sure the iterator is never empty, otherwise this variable is not defined? It seems like you are relying on a variable being defined by an iteration: foreach ($a as $b) { } // $b is defined here only if $a has elements, for example if $a is array() // then $b would not be defined here. To avoid that, we recommend to set a // default value for $b. // Better $b = 0; // or whatever default makes sense in your context foreach ($a as $b) { } // $b is now guaranteed to be defined here. Loading history...
292			$this->assertSame($expectedObjects, $values);
293
294			$this->assertFalse($this->pager->valid());
295
296			$this->callMethod($this->pager, 'resetIterator');
297			$this->assertTrue($this->pager->valid());
298			}
299
300			public function testValid(): void
301			{
302			$this->pager->expects($this->any())
303			->method('getResults')
304			->willReturn([]);
305
306			$this->assertFalse($this->pager->valid());
307			}
308
309			public function testNext(): void
310			{
311			$this->pager->expects($this->any())
312			->method('getResults')
313			->willReturn([]);
314
315			$this->assertFalse($this->pager->next());
316			}
317
318			public function testKey(): void
319			{
320			$this->pager->expects($this->any())
321			->method('getResults')
322			->willReturn([123 => new \stdClass()]);
323
324			$this->assertSame(123, $this->pager->key());
325			}
326
327			public function testCurrent(): void
328			{
329			$object = new \stdClass();
330
331			$this->pager->expects($this->any())
332			->method('getResults')
333			->willReturn([$object]);
334
335			$this->assertSame($object, $this->pager->current());
336			}
337
338			public function testGetCursor(): void
339			{
340			$this->assertSame(1, $this->pager->getCursor());
341
342			$this->pager->setCursor(0);
343			$this->assertSame(1, $this->pager->getCursor());
344
345			$this->pager->setCursor(300);
346			$this->assertSame(0, $this->pager->getCursor());
347
348			$this->callMethod($this->pager, 'setNbResults', [100]);
349
350			$this->pager->setCursor(5);
351			$this->assertSame(5, $this->pager->getCursor());
352
353			$this->pager->setCursor(300);
354			$this->assertSame(100, $this->pager->getCursor());
355			}
356
357			public function testGetObjectByCursor(): void
358			{
359			$object1 = new \stdClass();
360			$object1->foo = 'bar1';
361
362			$object2 = new \stdClass();
363			$object2->foo = 'bar2';
364
365			$object3 = new \stdClass();
366			$object3->foo = 'bar3';
367
368			$this->callMethod($this->pager, 'setNbResults', [3]);
369
370			$query = $this->createMock(ProxyQueryInterface::class);
371
372			$query->expects($this->any())
373			->method('setFirstResult')
374			->willReturn($query);
375
376			$query->expects($this->any())
377			->method('setMaxResults')
378			->willReturn($query);
379
380			$id = 0;
381			$query->expects($this->any())
382			->method('execute')
383			->willReturnCallback(static function () use (&$id, $object1, $object2, $object3) {
384			switch ($id) {
385			case 0:
386			return [$object1];
387
388			case 1:
389			return [$object2];
390
391			case 2:
392			return [$object3];
393			}
394			});
395
396			$this->pager->setQuery($query);
397
398			$this->assertSame($object1, $this->pager->getObjectByCursor(1));
399			$this->assertSame(1, $this->pager->getCursor());
400
401			$id = 1;
402			$this->assertSame($object2, $this->pager->getObjectByCursor(2));
403			$this->assertSame(2, $this->pager->getCursor());
404
405			$id = 2;
406			$this->assertSame($object3, $this->pager->getObjectByCursor(3));
407			$this->assertSame(3, $this->pager->getCursor());
408
409			$id = 3;
410			$this->assertNull($this->pager->getObjectByCursor(4));
411			$this->assertSame(3, $this->pager->getCursor());
412			}
413
414			public function testGetFirstPage(): void
415			{
416			$this->assertSame(1, $this->pager->getFirstPage());
417			}
418
419			public function testGetNextPage(): void
420			{
421			$this->assertSame(1, $this->pager->getNextPage());
422
423			$this->pager->setPage(3);
424			$this->callMethod($this->pager, 'setLastPage', [20]);
425			$this->assertSame(4, $this->pager->getNextPage());
426
427			$this->pager->setPage(21);
428			$this->assertSame(20, $this->pager->getNextPage());
429			}
430
431			public function testGetPreviousPage(): void
432			{
433			$this->assertSame(1, $this->pager->getPreviousPage());
434
435			$this->pager->setPage(3);
436			$this->assertSame(2, $this->pager->getPreviousPage());
437
438			$this->pager->setPage(21);
439			$this->assertSame(20, $this->pager->getPreviousPage());
440			}
441
442			public function testGetFirstIndex(): void
443			{
444			$this->assertSame(1, $this->pager->getFirstIndex());
445
446			$this->pager->setMaxPerPage(0);
447			$this->pager->setPage(0);
448			$this->assertSame(1, $this->pager->getFirstIndex());
449
450			$this->pager->setPage(2);
451			$this->pager->setMaxPerPage(10);
452			$this->assertSame(11, $this->pager->getFirstIndex());
453
454			$this->pager->setPage(4);
455			$this->pager->setMaxPerPage(7);
456			$this->assertSame(22, $this->pager->getFirstIndex());
457			}
458
459			public function testGetLastIndex(): void
460			{
461			$this->assertSame(0, $this->pager->getLastIndex());
462
463			$this->pager->setMaxPerPage(0);
464			$this->pager->setPage(0);
465			$this->assertSame(0, $this->pager->getLastIndex());
466
467			$this->callMethod($this->pager, 'setNbResults', [100]);
468
469			$this->assertSame(100, $this->pager->getLastIndex());
470
471			$this->pager->setPage(2);
472			$this->assertSame(0, $this->pager->getLastIndex());
473
474			$this->pager->setMaxPerPage(10);
475			$this->assertSame(20, $this->pager->getLastIndex());
476
477			$this->pager->setPage(11);
478			$this->assertSame(100, $this->pager->getLastIndex());
479			}
480
481			public function testGetNext(): void
482			{
483			$this->assertNull($this->pager->getNext());
484
485			$object1 = new \stdClass();
486			$object1->foo = 'bar1';
487
488			$object2 = new \stdClass();
489			$object2->foo = 'bar2';
490
491			$object3 = new \stdClass();
492			$object3->foo = 'bar3';
493
494			$this->callMethod($this->pager, 'setNbResults', [3]);
495
496			$query = $this->createMock(ProxyQueryInterface::class);
497
498			$query->expects($this->any())
499			->method('setFirstResult')
500			->willReturn($query);
501
502			$query->expects($this->any())
503			->method('setMaxResults')
504			->willReturn($query);
505
506			$id = 0;
507			$query->expects($this->any())
508			->method('execute')
509			->willReturnCallback(static function () use (&$id, $object1, $object2, $object3) {
510			switch ($id) {
511			case 0:
512			return [$object1];
513
514			case 1:
515			return [$object2];
516
517			case 2:
518			return [$object3];
519			}
520			});
521
522			$this->pager->setQuery($query);
523
524			$this->pager->setCursor(1);
525			$this->assertSame($object1, $this->pager->getCurrent());
526
527			++$id;
528			$this->assertSame($object2, $this->pager->getNext());
529
530			++$id;
531			$this->assertSame($object3, $this->pager->getNext());
532
533			++$id;
534			$this->assertNull($this->pager->getNext());
535			}
536
537			public function testGetPrevious(): void
538			{
539			$this->assertNull($this->pager->getPrevious());
540
541			$object1 = new \stdClass();
542			$object1->foo = 'bar1';
543
544			$object2 = new \stdClass();
545			$object2->foo = 'bar2';
546
547			$object3 = new \stdClass();
548			$object3->foo = 'bar3';
549
550			$this->callMethod($this->pager, 'setNbResults', [3]);
551
552			$query = $this->createMock(ProxyQueryInterface::class);
553
554			$query->expects($this->any())
555			->method('setFirstResult')
556			->willReturn($query);
557
558			$query->expects($this->any())
559			->method('setMaxResults')
560			->willReturn($query);
561
562			$id = 2;
563			$query->expects($this->any())
564			->method('execute')
565			->willReturnCallback(static function () use (&$id, $object1, $object2, $object3) {
566			switch ($id) {
567			case 0:
568			return [$object1];
569
570			case 1:
571			return [$object2];
572
573			case 2:
574			return [$object3];
575			}
576			});
577
578			$this->pager->setQuery($query);
579
580			$this->pager->setCursor(2);
581			$this->assertSame($object3, $this->pager->getCurrent());
582
583			--$id;
584			$this->assertSame($object2, $this->pager->getPrevious());
585
586			--$id;
587			$this->assertSame($object1, $this->pager->getPrevious());
588
589			--$id;
590			$this->assertNull($this->pager->getPrevious());
591			}
592
593			public function testSerialize(): void
594			{
595			$pagerClone = clone $this->pager;
596			$data = $this->pager->serialize();
597			$this->assertNotEmpty($data);
598
599			$this->pager->setPage(12);
600			$this->pager->setMaxPerPage(4);
601			$this->pager->setMaxPageLinks(6);
602
603			$this->pager->unserialize($data);
604			$this->assertSame($pagerClone->getPage(), $this->pager->getPage());
605			$this->assertSame($pagerClone->getMaxPerPage(), $this->pager->getMaxPerPage());
606			$this->assertSame($pagerClone->getMaxPageLinks(), $this->pager->getMaxPageLinks());
607			}
608
609			public function testUnserialize(): void
610			{
611			$serialized = [
612			'page' => 6,
613			'maxPerPage' => 7,
614			'maxPageLinks' => 5,
615			'lastPage' => 4,
616			'nbResults' => 30,
617			'cursor' => 3,
618			'parameters' => ['foo' => 'bar'],
619			'currentMaxLink' => 2,
620			'maxRecordLimit' => 22,
621			'countColumn' => ['idx'],
622			];
623
624			$this->pager->expects($this->any())
625			->method('getResults')
626			->willReturn([]);
627			$this->pager->current();
628
629			$this->pager->unserialize(serialize($serialized));
630
631			$this->assertSame(7, $this->pager->getMaxPerPage());
632			$this->assertSame(6, $this->pager->getPage());
633			$this->assertSame(5, $this->pager->getMaxPageLinks());
634			$this->assertSame(4, $this->pager->getLastPage());
635			$this->assertSame(['idx'], $this->pager->getCountColumn());
636			$this->assertSame(30, $this->pager->getNbResults());
637			$this->assertSame(3, $this->pager->getCursor());
638			$this->assertSame(['foo' => 'bar'], $this->pager->getParameters());
639			$this->assertSame(2, $this->pager->getCurrentMaxLink());
640			$this->assertSame(22, $this->pager->getMaxRecordLimit());
641			$this->assertNull($this->pager->getQuery());
642			}
643
644			protected function callMethod($obj, $name, array $args = [])
645			{
646			$class = new \ReflectionClass($obj);
647			$method = $class->getMethod($name);
648			$method->setAccessible(true);
649
650			return $method->invokeArgs($obj, $args);
651			}
652			}
653

sonata-project / SonataAdminBundle

Push — 3.x ( e95e95...638cd1 )

tests/Datagrid/PagerTest.php (1 issue)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like