LampagerBehaviorTest::valueProvider() - Code Metrics - Inspection of "Migrate to new PHP analysis" - lampager/lampager-cakephp - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#5)

by Chito
created 2020-01-01 16:05 UTC
LampagerBehaviorTest::valueProvider() B

↳ Parent: LampagerBehaviorTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	611
Code Lines	402
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	0
Metric	Value
eloc	402
c	1
b	0
f	0
dl	0
loc	611
rs	8
cc	1
nc	1
nop	0
How to fix Long Method

<?php

namespace Lampager\Cake\Test\TestCase\Model\Behavior;

use Cake\I18n\Time;
use Cake\ORM\Entity;
use Cake\ORM\Table;
use Cake\ORM\TableRegistry;
use Lampager\Cake\Model\Behavior\LampagerBehavior;
use Lampager\Cake\ORM\Query;
use Lampager\Cake\Test\TestCase\TestCase;
use Lampager\PaginationResult;

class LampagerBehaviorTest extends TestCase
{
    public $fixtures = [
        'plugin.Lampager\\Cake.Posts',
    ];

    /**
     * @param        LampagerBehavior|Table $factory
     * @param        PaginationResult       $expected
     * @dataProvider valueProvider
     * @dataProvider queryExpressionProvider
     */
    public function testLampager(callable $factory, PaginationResult $expected)
    {
        /** @var LampagerBehavior|Table $posts */
        $posts = TableRegistry::getTableLocator()->get('Posts');
        $posts->addBehavior(LampagerBehavior::class);

        /** @var Query $query */
        $query = $factory($posts);
        $this->assertJsonEquals($expected, $query->all());
    }

    public function valueProvider()
    {
        yield 'Ascending forward start inclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->limit(3)
                    ->orderAsc('modified')
                    ->orderAsc('id');
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => null,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Ascending forward start exclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderAsc('modified')
                    ->orderAsc('id');
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => null,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Ascending forward inclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->limit(3)
                    ->orderAsc('modified')
                    ->orderAsc('id')
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Ascending forward exclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderAsc('modified')
                    ->orderAsc('id')
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => false,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Ascending backward start inclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->limit(3)
                    ->orderAsc('modified')
                    ->orderAsc('id');
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => null,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Ascending backward start exclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderAsc('modified')
                    ->orderAsc('id');
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => null,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Ascending backward inclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->limit(3)
                    ->orderAsc('modified')
                    ->orderAsc('id')
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => false,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Ascending backward exclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderAsc('modified')
                    ->orderAsc('id')
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => false,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Descending forward start inclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->limit(3)
                    ->orderDesc('modified')
                    ->orderDesc('id');
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => null,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Descending forward start exclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderDesc('modified')
                    ->orderDesc('id');
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => null,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Descending forward inclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->limit(3)
                    ->orderDesc('modified')
                    ->orderDesc('id')
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => false,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Descending forward exclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderDesc('modified')
                    ->orderDesc('id')
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => false,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Descending backward start inclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->limit(3)
                    ->orderDesc('modified')
                    ->orderDesc('id');
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ],
                    'hasNext' => null,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Descending backward start exclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderDesc('modified')
                    ->orderDesc('id');
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => null,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Descending backward inclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->limit(3)
                    ->orderDesc('modified')
                    ->orderDesc('id')
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ],
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Descending backward exclusive' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderDesc('modified')
                    ->orderDesc('id')
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => false,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];
    }

    public function queryExpressionProvider()
    {
        yield 'Ascending forward start inclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->limit(3)
                    ->orderAsc($posts->query()->newExpr('modified'))
                    ->orderAsc($posts->/** @scrutinizer ignore-call */ query()->newExpr('modified'))
                    ->orderAsc($posts->query()->newExpr('id'));
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => null,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Ascending forward inclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->limit(3)
                    ->orderAsc($posts->query()->newExpr('modified'))
                    ->orderAsc($posts->query()->newExpr('id'))
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Ascending forward exclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderAsc($posts->query()->newExpr('modified'))
                    ->orderAsc($posts->query()->newExpr('id'))
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => false,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Ascending backward start inclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->limit(3)
                    ->orderAsc($posts->query()->newExpr('modified'))
                    ->orderAsc($posts->query()->newExpr('id'));
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => null,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Ascending backward start exclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderAsc($posts->query()->newExpr('modified'))
                    ->orderAsc($posts->query()->newExpr('id'));
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => null,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Ascending backward inclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->limit(3)
                    ->orderAsc($posts->query()->newExpr('modified'))
                    ->orderAsc($posts->query()->newExpr('id'))
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => false,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Ascending backward exclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderAsc($posts->query()->newExpr('modified'))
                    ->orderAsc($posts->query()->newExpr('id'))
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => false,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Descending forward start inclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->limit(3)
                    ->orderDesc($posts->query()->newExpr('modified'))
                    ->orderDesc($posts->query()->newExpr('id'));
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => null,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Descending forward start exclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderDesc($posts->query()->newExpr('modified'))
                    ->orderDesc($posts->query()->newExpr('id'));
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => null,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Descending forward inclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->limit(3)
                    ->orderDesc($posts->query()->newExpr('modified'))
                    ->orderDesc($posts->query()->newExpr('id'))
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => false,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Descending forward exclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->forward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderDesc($posts->query()->newExpr('modified'))
                    ->orderDesc($posts->query()->newExpr('id'))
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => false,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Descending backward start inclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->limit(3)
                    ->orderDesc($posts->query()->newExpr('modified'))
                    ->orderDesc($posts->query()->newExpr('id'));
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ],
                    'hasNext' => null,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Descending backward start exclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderDesc($posts->query()->newExpr('modified'))
                    ->orderDesc($posts->query()->newExpr('id'));
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                    'hasNext' => null,
                    'nextCursor' => null,
                ]
            ),
        ];

        yield 'Descending backward inclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->limit(3)
                    ->orderDesc($posts->query()->newExpr('modified'))
                    ->orderDesc($posts->query()->newExpr('id'))
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                    new Entity([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => true,
                    'previousCursor' => [
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ],
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 1,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];

        yield 'Descending backward exclusive with QueryExpression' => [
            function (Table $posts) {
                /** @var LampagerBehavior|Table $posts */
                return $posts->lampager()
                    ->backward()
                    ->seekable()
                    ->exclusive()
                    ->limit(3)
                    ->orderDesc($posts->query()->newExpr('modified'))
                    ->orderDesc($posts->query()->newExpr('id'))
                    ->cursor([
                        'id' => 3,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]);
            },
            new PaginationResult(
                [
                    new Entity([
                        'id' => 4,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 2,
                        'modified' => new Time('2017-01-01 11:00:00'),
                    ]),
                    new Entity([
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ]),
                ],
                [
                    'hasPrevious' => false,
                    'previousCursor' => null,
                    'hasNext' => true,
                    'nextCursor' => [
                        'id' => 5,
                        'modified' => new Time('2017-01-01 10:00:00'),
                    ],
                ]
            ),
        ];
    }
}

lampager / lampager-cakephp

Pull Request — master (#5)

LampagerBehaviorTest::valueProvider() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like
