DoctrineORMAdapterTest::testGetSlice() - Code Metrics - whiteoctober/Pagerfanta - Measure and Improve Code Quality continuously with Scrutinizer

DoctrineORMAdapterTest::testGetSlice() A
last analyzed 2020-06-09 12:05 UTC

↳ Parent: DoctrineORMAdapterTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	10
rs	9.9332
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php

namespace Pagerfanta\Tests\Adapter;

use Doctrine\ORM\Query;
use Doctrine\ORM\Tools\SchemaTool;
use Pagerfanta\Adapter\DoctrineORMAdapter;
use Pagerfanta\Tests\Adapter\DoctrineORM\DoctrineORMTestCase;
use Pagerfanta\Tests\Adapter\DoctrineORM\User;
use Pagerfanta\Tests\Adapter\DoctrineORM\Group;
use Pagerfanta\Tests\Adapter\DoctrineORM\Person;

class DoctrineORMAdapterTest extends DoctrineORMTestCase
{
    private $user1;
    private $user2;

    public function setUp()
    {
        parent::setUp();

        $schemaTool = new SchemaTool($this->entityManager);
        $schemaTool->createSchema(array(
            $this->entityManager->getClassMetadata('Pagerfanta\Tests\Adapter\DoctrineORM\User'),
            $this->entityManager->getClassMetadata('Pagerfanta\Tests\Adapter\DoctrineORM\Group'),
            $this->entityManager->getClassMetadata('Pagerfanta\Tests\Adapter\DoctrineORM\Person'),
        ));

        $this->user1 = $user = new User();
        $this->user2 = $user2 = new User();
        $group1 = new Group();
        $group2 = new Group();
        $group3 = new Group();
        $user->groups[] = $group1;
        $user->groups[] = $group2;
        $user->groups[] = $group3;
        $user2->groups[] = $group1;
        $author1 = new Person();
        $author1->name = 'Foo';
        $author1->biography = 'Baz bar';
        $author2 = new Person();
        $author2->name = 'Bar';
        $author2->biography = 'Bar baz';

        $this->entityManager->persist($user);
        $this->entityManager->persist($user2);
        $this->entityManager->persist($group1);
        $this->entityManager->persist($group2);
        $this->entityManager->persist($group3);
        $this->entityManager->persist($author1);
        $this->entityManager->persist($author2);
        $this->entityManager->flush();
    }

    public function testAdapterCount()
    {
        $dql = "SELECT u FROM Pagerfanta\Tests\Adapter\DoctrineORM\User u";
        $query = $this->entityManager->createQuery($dql);

        $adapter = new DoctrineORMAdapter($query);
        $this->assertEquals(2, $adapter->getNbResults());
    }

    public function testAdapterCountFetchJoin()
    {
        $dql = "SELECT u, g FROM Pagerfanta\Tests\Adapter\DoctrineORM\User u INNER JOIN u.groups g";
        $query = $this->entityManager->createQuery($dql);

        $adapter = new DoctrineORMAdapter($query);
        $this->assertEquals(2, $adapter->getNbResults());
    }

    public function testGetSlice()
    {
        $dql = "SELECT u FROM Pagerfanta\Tests\Adapter\DoctrineORM\User u";
        $query = $this->entityManager->createQuery($dql);

        $adapter = new DoctrineORMAdapter($query);
        $this->assertEquals(1, count( $adapter->getSlice(0, 1)) );
        $this->assertEquals(2, count( $adapter->getSlice(0, 10)) );
        $this->assertEquals(1, count( $adapter->getSlice(1, 1)) );
    }

    public function testGetSliceFetchJoin()
    {
        $dql = "SELECT u FROM Pagerfanta\Tests\Adapter\DoctrineORM\User u INNER JOIN u.groups g";
        $query = $this->entityManager->createQuery($dql);

        $adapter = new DoctrineORMAdapter($query, true);
        $this->assertEquals(1, count( $adapter->getSlice(0, 1)) );
        $this->assertEquals(2, count( $adapter->getSlice(0, 10)) );
        $this->assertEquals(1, count( $adapter->getSlice(1, 1)) );
    }

    public function testCountAfterSlice()
    {
        $dql = "SELECT u FROM Pagerfanta\Tests\Adapter\DoctrineORM\User u";
        $query = $this->entityManager->createQuery($dql);

        $adapter = new DoctrineORMAdapter($query);
        $adapter->getSlice(0, 1);
        $this->assertEquals(2, $adapter->getNbResults() );
    }

    public function testMultipleRoot()
    {
        $this->markTestIncomplete('Multiple roots are not supported currently');
        $dql = <<<DQL
        SELECT u, g FROM
            Pagerfanta\Tests\Adapter\DoctrineORM\User u,
            Pagerfanta\Tests\Adapter\DoctrineORM\Group g
DQL;
        $query = $this->entityManager->createQuery($dql);

        $adapter = new DoctrineORMAdapter($query);
        $this->assertCount(5, $adapter->getSlice(0, 100));
        $this->assertCount(4, $adapter->getSlice(0, 4));
        $this->assertEquals(5, $adapter->getNbResults());
    }

    public function testMixedResult()
    {
        $dql = <<<DQL
        SELECT p, p.name FROM
            Pagerfanta\Tests\Adapter\DoctrineORM\Person p
DQL;
        $query = $this->entityManager->createQuery($dql);

        $adapter = new DoctrineORMAdapter($query);
        $this->assertEquals(2, $adapter->getNbResults());
        $items = $adapter->getSlice(0, 10);
        $this->assertCount(2, $items);
        $this->assertArrayHasKey('name', $items[0]);
    }

    public function testCaseBasedQuery()
    {
        if (version_compare(\Doctrine\ORM\Version::VERSION, '2.2.0-DEV', '<')) {
            $this->markTestSkipped('Only recent orm version can test against this query.');
        }

        $dql = <<<DQL
            SELECT p,
              CASE
                WHEN p.name LIKE :keyword
                  AND p.biography LIKE :keyword
                THEN 0

                WHEN p.name LIKE :keyword
                THEN 1

                WHEN p.biography LIKE :keyword
                THEN 2

                ELSE 3
              END AS relevance
            FROM Pagerfanta\Tests\Adapter\DoctrineORM\Person p
            WHERE (
              p.name LIKE :keyword
              OR p.biography LIKE :keyword
            )
            GROUP BY p.id
            ORDER BY relevance ASC, p.id DESC
DQL;
        $query = $this->entityManager->createQuery($dql);
        $query->setParameter('keyword', '%Foo%');

        $adapter = new DoctrineORMAdapter($query);
        $this->assertEquals(1, $adapter->getNbResults());
        $items = $adapter->getSlice(0, 10);
        $this->assertEquals('Foo', $items[0][0]->name);
        $this->assertEquals(1, $items[0]['relevance']);
    }

    public function testItShouldAcceptAQueryBuilder()
    {
        $queryBuilder = $this->entityManager->createQueryBuilder()
            ->select('u')
            ->from('Pagerfanta\Tests\Adapter\DoctrineORM\User', 'u');

        $adapter = new DoctrineORMAdapter($queryBuilder);

        $this->assertSame(2, $adapter->getNbResults());

        $slice = $adapter->getSlice(0, 10);
        $this->assertSame(2, count($slice));

        $users = array($this->user1, $this->user2);
        $userClass = 'Pagerfanta\Tests\Adapter\DoctrineORM\User';
        foreach ($users as $key => $user) {
            $this->assertInstanceOf($userClass, $slice[$key]);
            $this->assertSame($user->id, $slice[$key]->id);
        }
    }
}


1			<?php
2
3			namespace Pagerfanta\Tests\Adapter;
4
5			use Doctrine\ORM\Query;
6			use Doctrine\ORM\Tools\SchemaTool;
7			use Pagerfanta\Adapter\DoctrineORMAdapter;
8			use Pagerfanta\Tests\Adapter\DoctrineORM\DoctrineORMTestCase;
9			use Pagerfanta\Tests\Adapter\DoctrineORM\User;
10			use Pagerfanta\Tests\Adapter\DoctrineORM\Group;
11			use Pagerfanta\Tests\Adapter\DoctrineORM\Person;
12
13			class DoctrineORMAdapterTest extends DoctrineORMTestCase
14			{
15			private $user1;
16			private $user2;
17
18			public function setUp()
19			{
20			parent::setUp();
21
22			$schemaTool = new SchemaTool($this->entityManager);
23			$schemaTool->createSchema(array(
24			$this->entityManager->getClassMetadata('Pagerfanta\Tests\Adapter\DoctrineORM\User'),
25			$this->entityManager->getClassMetadata('Pagerfanta\Tests\Adapter\DoctrineORM\Group'),
26			$this->entityManager->getClassMetadata('Pagerfanta\Tests\Adapter\DoctrineORM\Person'),
27			));
28
29			$this->user1 = $user = new User();
30			$this->user2 = $user2 = new User();
31			$group1 = new Group();
32			$group2 = new Group();
33			$group3 = new Group();
34			$user->groups[] = $group1;
35			$user->groups[] = $group2;
36			$user->groups[] = $group3;
37			$user2->groups[] = $group1;
38			$author1 = new Person();
39			$author1->name = 'Foo';
40			$author1->biography = 'Baz bar';
41			$author2 = new Person();
42			$author2->name = 'Bar';
43			$author2->biography = 'Bar baz';
44
45			$this->entityManager->persist($user);
46			$this->entityManager->persist($user2);
47			$this->entityManager->persist($group1);
48			$this->entityManager->persist($group2);
49			$this->entityManager->persist($group3);
50			$this->entityManager->persist($author1);
51			$this->entityManager->persist($author2);
52			$this->entityManager->flush();
53			}
54
55			public function testAdapterCount()
56			{
57			$dql = "SELECT u FROM Pagerfanta\Tests\Adapter\DoctrineORM\User u";
58			$query = $this->entityManager->createQuery($dql);
59
60			$adapter = new DoctrineORMAdapter($query);
61			$this->assertEquals(2, $adapter->getNbResults());
62			}
63
64			public function testAdapterCountFetchJoin()
65			{
66			$dql = "SELECT u, g FROM Pagerfanta\Tests\Adapter\DoctrineORM\User u INNER JOIN u.groups g";
67			$query = $this->entityManager->createQuery($dql);
68
69			$adapter = new DoctrineORMAdapter($query);
70			$this->assertEquals(2, $adapter->getNbResults());
71			}
72
73			public function testGetSlice()
74			{
75			$dql = "SELECT u FROM Pagerfanta\Tests\Adapter\DoctrineORM\User u";
76			$query = $this->entityManager->createQuery($dql);
77
78			$adapter = new DoctrineORMAdapter($query);
79			$this->assertEquals(1, count( $adapter->getSlice(0, 1)) );
80			$this->assertEquals(2, count( $adapter->getSlice(0, 10)) );
81			$this->assertEquals(1, count( $adapter->getSlice(1, 1)) );
82			}
83
84			public function testGetSliceFetchJoin()
85			{
86			$dql = "SELECT u FROM Pagerfanta\Tests\Adapter\DoctrineORM\User u INNER JOIN u.groups g";
87			$query = $this->entityManager->createQuery($dql);
88
89			$adapter = new DoctrineORMAdapter($query, true);
90			$this->assertEquals(1, count( $adapter->getSlice(0, 1)) );
91			$this->assertEquals(2, count( $adapter->getSlice(0, 10)) );
92			$this->assertEquals(1, count( $adapter->getSlice(1, 1)) );
93			}
94
95			public function testCountAfterSlice()
96			{
97			$dql = "SELECT u FROM Pagerfanta\Tests\Adapter\DoctrineORM\User u";
98			$query = $this->entityManager->createQuery($dql);
99
100			$adapter = new DoctrineORMAdapter($query);
101			$adapter->getSlice(0, 1);
102			$this->assertEquals(2, $adapter->getNbResults() );
103			}
104
105			public function testMultipleRoot()
106			{
107			$this->markTestIncomplete('Multiple roots are not supported currently');
108			$dql = <<<DQL
109			SELECT u, g FROM
110			Pagerfanta\Tests\Adapter\DoctrineORM\User u,
111			Pagerfanta\Tests\Adapter\DoctrineORM\Group g
112			DQL;
113			$query = $this->entityManager->createQuery($dql);
114
115			$adapter = new DoctrineORMAdapter($query);
116			$this->assertCount(5, $adapter->getSlice(0, 100));
117			$this->assertCount(4, $adapter->getSlice(0, 4));
118			$this->assertEquals(5, $adapter->getNbResults());
119			}
120
121			public function testMixedResult()
122			{
123			$dql = <<<DQL
124			SELECT p, p.name FROM
125			Pagerfanta\Tests\Adapter\DoctrineORM\Person p
126			DQL;
127			$query = $this->entityManager->createQuery($dql);
128
129			$adapter = new DoctrineORMAdapter($query);
130			$this->assertEquals(2, $adapter->getNbResults());
131			$items = $adapter->getSlice(0, 10);
132			$this->assertCount(2, $items);
133			$this->assertArrayHasKey('name', $items[0]);
134			}
135
136			public function testCaseBasedQuery()
137			{
138			if (version_compare(\Doctrine\ORM\Version::VERSION, '2.2.0-DEV', '<')) {
139			$this->markTestSkipped('Only recent orm version can test against this query.');
140			}
141
142			$dql = <<<DQL
143			SELECT p,
144			CASE
145			WHEN p.name LIKE :keyword
146			AND p.biography LIKE :keyword
147			THEN 0
148
149			WHEN p.name LIKE :keyword
150			THEN 1
151
152			WHEN p.biography LIKE :keyword
153			THEN 2
154
155			ELSE 3
156			END AS relevance
157			FROM Pagerfanta\Tests\Adapter\DoctrineORM\Person p
158			WHERE (
159			p.name LIKE :keyword
160			OR p.biography LIKE :keyword
161			)
162			GROUP BY p.id
163			ORDER BY relevance ASC, p.id DESC
164			DQL;
165			$query = $this->entityManager->createQuery($dql);
166			$query->setParameter('keyword', '%Foo%');
167
168			$adapter = new DoctrineORMAdapter($query);
169			$this->assertEquals(1, $adapter->getNbResults());
170			$items = $adapter->getSlice(0, 10);
171			$this->assertEquals('Foo', $items[0][0]->name);
172			$this->assertEquals(1, $items[0]['relevance']);
173			}
174
175			public function testItShouldAcceptAQueryBuilder()
176			{
177			$queryBuilder = $this->entityManager->createQueryBuilder()
178			->select('u')
179			->from('Pagerfanta\Tests\Adapter\DoctrineORM\User', 'u');
180
181			$adapter = new DoctrineORMAdapter($queryBuilder);
182
183			$this->assertSame(2, $adapter->getNbResults());
184
185			$slice = $adapter->getSlice(0, 10);
186			$this->assertSame(2, count($slice));
187
188			$users = array($this->user1, $this->user2);
189			$userClass = 'Pagerfanta\Tests\Adapter\DoctrineORM\User';
190			foreach ($users as $key => $user) {
191			$this->assertInstanceOf($userClass, $slice[$key]);
192			$this->assertSame($user->id, $slice[$key]->id);
193			}
194			}
195			}
196

whiteoctober / Pagerfanta

DoctrineORMAdapterTest::testGetSlice() A last analyzed 2020-06-09 12:05 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

DoctrineORMAdapterTest::testGetSlice() A
last analyzed 2020-06-09 12:05 UTC