EntryManagerTest::testCountAll() - Code Metrics - Inspection of "v3.0.0" - sunrise-php/awesome-skeleton - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#10)

by Anatoly

created 2021-02-07 14:16 UTC

EntryManagerTest::testCountAll() A

↳ Parent: EntryManagerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	16
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

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

<?php declare(strict_types=1);

namespace App\Bundle\Example\Tests\Service;

/**
 * Import classes
 */
use App\Exception\EntityNotFoundException;
use App\Exception\InvalidEntityException;
use App\Tests\ContainerAwareTrait;
use App\Tests\DatabaseSchemaToolTrait;
use PHPUnit\Framework\TestCase;

/**
 * EntryManagerTest
 */
class EntryManagerTest extends TestCase
{
    use ContainerAwareTrait;
    use DatabaseSchemaToolTrait;

    /**
     * @return void
     *
     * @runInSeparateProcess
     */
    public function testCountAll() : void
    {
        $container = $this->getContainer();
        $doctrine = $container->get('doctrine');

        $entityManager = $doctrine->getManager('master');
        $this->createDatabaseSchema($entityManager);

        $entryManager = $container->get('entryManager');
        $this->assertSame(0, $entryManager->countAll());

        $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
        $this->assertSame(1, $entryManager->countAll());

        $entryManager->create(['name' => 'bar', 'slug' => 'bar']);
        $this->assertSame(2, $entryManager->countAll());
    }

    /**
     * @return void
     *
     * @runInSeparateProcess
     */
    public function testList() : void
    {
        $container = $this->getContainer();
        $doctrine = $container->get('doctrine');

        $entityManager = $doctrine->getManager('master');
        $this->createDatabaseSchema($entityManager);

        $entryManager = $container->get('entryManager');
        // the database MUST be empty...
        $this->assertSame(0, $entryManager->countAll());

        $entries = $entryManager->getList(null, null);
        $this->assertSame([], $entries);

        $foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
        $entries = $entryManager->getList(null, null);
        $this->assertCount(1, $entries);
        $this->assertSame($foo->getId()->toString(), (string) $entries[0]->getId());

        $bar = $entryManager->create(['name' => 'bar', 'slug' => 'bar']);
        $entries = $entryManager->getList(null, null);
        $this->assertCount(2, $entries);
        $this->assertSame($bar->getId()->toString(), (string) $entries[0]->getId());
        $this->assertSame($foo->getId()->toString(), (string) $entries[1]->getId());

        $entries = $entryManager->getList(1, null);
        $this->assertCount(1, $entries);
        $this->assertSame($bar->getId()->toString(), (string) $entries[0]->getId());

        $entries = $entryManager->getList(null, 1);
        $this->assertCount(1, $entries);
        $this->assertSame($foo->getId()->toString(), (string) $entries[0]->getId());
    }

    /**
     * @return void
     *
     * @runInSeparateProcess
     */
    public function testFindById() : void
    {
        $container = $this->getContainer();
        $doctrine = $container->get('doctrine');

        $entityManager = $doctrine->getManager('master');
        $this->createDatabaseSchema($entityManager);

        $entryManager = $container->get('entryManager');
        // the database MUST be empty...
        $this->assertSame(0, $entryManager->countAll());

        $foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
        $bar = $entryManager->create(['name' => 'bar', 'slug' => 'bar']);

        $found = $entryManager->findById($foo->getId()->toString());
        $this->assertSame($foo->getId()->toString(), (string) $found->getId());

        $found = $entryManager->findById($bar->getId()->toString());
        $this->assertSame($bar->getId()->toString(), (string) $found->getId());

        $this->expectException(EntityNotFoundException::class);
        $entryManager->findById('5b640dde-3503-444d-a234-b97b2752750b');
    }

    /**
     * @return void
     *
     * @runInSeparateProcess
     */
    public function testCreate() : void
    {
        $container = $this->getContainer();
        $doctrine = $container->get('doctrine');

        $entityManager = $doctrine->getManager('master');
        $this->createDatabaseSchema($entityManager);

        $entryManager = $container->get('entryManager');
        // the database MUST be empty...
        $this->assertSame(0, $entryManager->countAll());

        $foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
        $found = $entryManager->findById($foo->getId()->toString());
        $this->assertSame('foo', $found->getName());
        $this->assertSame('foo', $found->getSlug());

        $bar = $entryManager->create(['name' => 'bar', 'slug' => 'bar']);
        $found = $entryManager->findById($bar->getId()->toString());
        $this->assertSame('bar', $found->getName());
        $this->assertSame('bar', $found->getSlug());
    }

    /**
     * @return void
     *
     * @runInSeparateProcess
     */
    public function testCreateWithEmptyName() : void
    {
        $container = $this->getContainer();
        $doctrine = $container->get('doctrine');

        $entityManager = $doctrine->getManager('master');
        $this->createDatabaseSchema($entityManager);

        $entryManager = $container->get('entryManager');
        // the database MUST be empty...
        $this->assertSame(0, $entryManager->countAll());

        $this->expectException(InvalidEntityException::class);
        $entryManager->create(['name' => '', 'slug' => 'foo']);
    }

    /**
     * @return void
     *
     * @runInSeparateProcess
     */
    public function testCreateWithEmptySlug() : void
    {
        $container = $this->getContainer();
        $doctrine = $container->get('doctrine');

        $entityManager = $doctrine->getManager('master');
        $this->createDatabaseSchema($entityManager);

        $entryManager = $container->get('entryManager');
        // the database MUST be empty...
        $this->assertSame(0, $entryManager->countAll());

        $this->expectException(InvalidEntityException::class);
        $entryManager->create(['name' => 'foo', 'slug' => '']);
    }

    /**
     * @return void
     *
     * @runInSeparateProcess
     */
    public function testCreateWithNotUniqueSlug() : void
    {
        $container = $this->getContainer();
        $doctrine = $container->get('doctrine');

        $entityManager = $doctrine->getManager('master');
        $this->createDatabaseSchema($entityManager);

        $entryManager = $container->get('entryManager');
        // the database MUST be empty...
        $this->assertSame(0, $entryManager->countAll());

        $entryManager->create(['name' => 'foo', 'slug' => 'foo']);

        $this->expectException(InvalidEntityException::class);
        $entryManager->create(['name' => 'bar', 'slug' => 'foo']);
    }

    /**
     * @return void
     *
     * @runInSeparateProcess
     */
    public function testUpdate() : void
    {
        $container = $this->getContainer();
        $doctrine = $container->get('doctrine');

        $entityManager = $doctrine->getManager('master');
        $this->createDatabaseSchema($entityManager);

        $entryManager = $container->get('entryManager');
        // the database MUST be empty...
        $this->assertSame(0, $entryManager->countAll());

        $foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
        $entryManager->update($foo, ['name' => 'bar', 'slug' => 'bar']);
        $found = $entryManager->findById($foo->getId()->toString());

        $this->assertSame('bar', $found->getName());
        $this->assertSame('bar', $found->getSlug());
    }

    /**
     * @return void
     *
     * @runInSeparateProcess
     */
    public function testUpdateWithEmptyName() : void
    {
        $container = $this->getContainer();
        $doctrine = $container->get('doctrine');

        $entityManager = $doctrine->getManager('master');
        $this->createDatabaseSchema($entityManager);

        $entryManager = $container->get('entryManager');
        // the database MUST be empty...
        $this->assertSame(0, $entryManager->countAll());

        $foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);

        $this->expectException(InvalidEntityException::class);
        $entryManager->update($foo, ['name' => '', 'slug' => 'bar']);
    }

    /**
     * @return void
     *
     * @runInSeparateProcess
     */
    public function testUpdateWithEmptySlug() : void
    {
        $container = $this->getContainer();
        $doctrine = $container->get('doctrine');

        $entityManager = $doctrine->getManager('master');
        $this->createDatabaseSchema($entityManager);

        $entryManager = $container->get('entryManager');
        // the database MUST be empty...
        $this->assertSame(0, $entryManager->countAll());

        $foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);

        $this->expectException(InvalidEntityException::class);
        $entryManager->update($foo, ['name' => 'bar', 'slug' => '']);
    }

    /**
     * @return void
     *
     * @runInSeparateProcess
     */
    public function testUpdateWithNotUniqueSlug() : void
    {
        $container = $this->getContainer();
        $doctrine = $container->get('doctrine');

        $entityManager = $doctrine->getManager('master');
        $this->createDatabaseSchema($entityManager);

        $entryManager = $container->get('entryManager');
        // the database MUST be empty...
        $this->assertSame(0, $entryManager->countAll());

        $foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
        $bar = $entryManager->create(['name' => 'bar', 'slug' => 'bar']);


        $this->expectException(InvalidEntityException::class);
        $entryManager->update($foo, ['name' => 'baz', 'slug' => 'bar']);
    }

    /**
     * @return void
     *
     * @runInSeparateProcess
     */
    public function testDelete() : void
    {
        $container = $this->getContainer();
        $doctrine = $container->get('doctrine');

        $entityManager = $doctrine->getManager('master');
        $this->createDatabaseSchema($entityManager);

        $entryManager = $container->get('entryManager');
        // the database MUST be empty...
        $this->assertSame(0, $entryManager->countAll());

        $foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
        $entryManager->delete($foo);

        $this->expectException(EntityNotFoundException::class);
        $entryManager->findById($foo->getId()->toString());
    }
}


1			<?php declare(strict_types=1);
2
3			namespace App\Bundle\Example\Tests\Service;
4
5			/**
6			* Import classes
7			*/
8			use App\Exception\EntityNotFoundException;
9			use App\Exception\InvalidEntityException;
10			use App\Tests\ContainerAwareTrait;
11			use App\Tests\DatabaseSchemaToolTrait;
12			use PHPUnit\Framework\TestCase;
13
14			/**
15			* EntryManagerTest
16			*/
17			class EntryManagerTest extends TestCase
18			{
19			use ContainerAwareTrait;
20			use DatabaseSchemaToolTrait;
21
22			/**
23			* @return void
24			*
25			* @runInSeparateProcess
26			*/
27			public function testCountAll() : void
28			{
29			$container = $this->getContainer();
30			$doctrine = $container->get('doctrine');
31
32			$entityManager = $doctrine->getManager('master');
33			$this->createDatabaseSchema($entityManager);
34
35			$entryManager = $container->get('entryManager');
36			$this->assertSame(0, $entryManager->countAll());
37
38			$entryManager->create(['name' => 'foo', 'slug' => 'foo']);
39			$this->assertSame(1, $entryManager->countAll());
40
41			$entryManager->create(['name' => 'bar', 'slug' => 'bar']);
42			$this->assertSame(2, $entryManager->countAll());
43			}
44
45			/**
46			* @return void
47			*
48			* @runInSeparateProcess
49			*/
50			public function testList() : void
51			{
52			$container = $this->getContainer();
53			$doctrine = $container->get('doctrine');
54
55			$entityManager = $doctrine->getManager('master');
56			$this->createDatabaseSchema($entityManager);
57
58			$entryManager = $container->get('entryManager');
59			// the database MUST be empty...
60			$this->assertSame(0, $entryManager->countAll());
61
62			$entries = $entryManager->getList(null, null);
63			$this->assertSame([], $entries);
64
65			$foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
66			$entries = $entryManager->getList(null, null);
67			$this->assertCount(1, $entries);
68			$this->assertSame($foo->getId()->toString(), (string) $entries[0]->getId());
69
70			$bar = $entryManager->create(['name' => 'bar', 'slug' => 'bar']);
71			$entries = $entryManager->getList(null, null);
72			$this->assertCount(2, $entries);
73			$this->assertSame($bar->getId()->toString(), (string) $entries[0]->getId());
74			$this->assertSame($foo->getId()->toString(), (string) $entries[1]->getId());
75
76			$entries = $entryManager->getList(1, null);
77			$this->assertCount(1, $entries);
78			$this->assertSame($bar->getId()->toString(), (string) $entries[0]->getId());
79
80			$entries = $entryManager->getList(null, 1);
81			$this->assertCount(1, $entries);
82			$this->assertSame($foo->getId()->toString(), (string) $entries[0]->getId());
83			}
84
85			/**
86			* @return void
87			*
88			* @runInSeparateProcess
89			*/
90			public function testFindById() : void
91			{
92			$container = $this->getContainer();
93			$doctrine = $container->get('doctrine');
94
95			$entityManager = $doctrine->getManager('master');
96			$this->createDatabaseSchema($entityManager);
97
98			$entryManager = $container->get('entryManager');
99			// the database MUST be empty...
100			$this->assertSame(0, $entryManager->countAll());
101
102			$foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
103			$bar = $entryManager->create(['name' => 'bar', 'slug' => 'bar']);
104
105			$found = $entryManager->findById($foo->getId()->toString());
106			$this->assertSame($foo->getId()->toString(), (string) $found->getId());
107
108			$found = $entryManager->findById($bar->getId()->toString());
109			$this->assertSame($bar->getId()->toString(), (string) $found->getId());
110
111			$this->expectException(EntityNotFoundException::class);
112			$entryManager->findById('5b640dde-3503-444d-a234-b97b2752750b');
113			}
114
115			/**
116			* @return void
117			*
118			* @runInSeparateProcess
119			*/
120			public function testCreate() : void
121			{
122			$container = $this->getContainer();
123			$doctrine = $container->get('doctrine');
124
125			$entityManager = $doctrine->getManager('master');
126			$this->createDatabaseSchema($entityManager);
127
128			$entryManager = $container->get('entryManager');
129			// the database MUST be empty...
130			$this->assertSame(0, $entryManager->countAll());
131
132			$foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
133			$found = $entryManager->findById($foo->getId()->toString());
134			$this->assertSame('foo', $found->getName());
135			$this->assertSame('foo', $found->getSlug());
136
137			$bar = $entryManager->create(['name' => 'bar', 'slug' => 'bar']);
138			$found = $entryManager->findById($bar->getId()->toString());
139			$this->assertSame('bar', $found->getName());
140			$this->assertSame('bar', $found->getSlug());
141			}
142
143			/**
144			* @return void
145			*
146			* @runInSeparateProcess
147			*/
148			public function testCreateWithEmptyName() : void
149			{
150			$container = $this->getContainer();
151			$doctrine = $container->get('doctrine');
152
153			$entityManager = $doctrine->getManager('master');
154			$this->createDatabaseSchema($entityManager);
155
156			$entryManager = $container->get('entryManager');
157			// the database MUST be empty...
158			$this->assertSame(0, $entryManager->countAll());
159
160			$this->expectException(InvalidEntityException::class);
161			$entryManager->create(['name' => '', 'slug' => 'foo']);
162			}
163
164			/**
165			* @return void
166			*
167			* @runInSeparateProcess
168			*/
169			public function testCreateWithEmptySlug() : void
170			{
171			$container = $this->getContainer();
172			$doctrine = $container->get('doctrine');
173
174			$entityManager = $doctrine->getManager('master');
175			$this->createDatabaseSchema($entityManager);
176
177			$entryManager = $container->get('entryManager');
178			// the database MUST be empty...
179			$this->assertSame(0, $entryManager->countAll());
180
181			$this->expectException(InvalidEntityException::class);
182			$entryManager->create(['name' => 'foo', 'slug' => '']);
183			}
184
185			/**
186			* @return void
187			*
188			* @runInSeparateProcess
189			*/
190			public function testCreateWithNotUniqueSlug() : void
191			{
192			$container = $this->getContainer();
193			$doctrine = $container->get('doctrine');
194
195			$entityManager = $doctrine->getManager('master');
196			$this->createDatabaseSchema($entityManager);
197
198			$entryManager = $container->get('entryManager');
199			// the database MUST be empty...
200			$this->assertSame(0, $entryManager->countAll());
201
202			$entryManager->create(['name' => 'foo', 'slug' => 'foo']);
203
204			$this->expectException(InvalidEntityException::class);
205			$entryManager->create(['name' => 'bar', 'slug' => 'foo']);
206			}
207
208			/**
209			* @return void
210			*
211			* @runInSeparateProcess
212			*/
213			public function testUpdate() : void
214			{
215			$container = $this->getContainer();
216			$doctrine = $container->get('doctrine');
217
218			$entityManager = $doctrine->getManager('master');
219			$this->createDatabaseSchema($entityManager);
220
221			$entryManager = $container->get('entryManager');
222			// the database MUST be empty...
223			$this->assertSame(0, $entryManager->countAll());
224
225			$foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
226			$entryManager->update($foo, ['name' => 'bar', 'slug' => 'bar']);
227			$found = $entryManager->findById($foo->getId()->toString());
228
229			$this->assertSame('bar', $found->getName());
230			$this->assertSame('bar', $found->getSlug());
231			}
232
233			/**
234			* @return void
235			*
236			* @runInSeparateProcess
237			*/
238			public function testUpdateWithEmptyName() : void
239			{
240			$container = $this->getContainer();
241			$doctrine = $container->get('doctrine');
242
243			$entityManager = $doctrine->getManager('master');
244			$this->createDatabaseSchema($entityManager);
245
246			$entryManager = $container->get('entryManager');
247			// the database MUST be empty...
248			$this->assertSame(0, $entryManager->countAll());
249
250			$foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
251
252			$this->expectException(InvalidEntityException::class);
253			$entryManager->update($foo, ['name' => '', 'slug' => 'bar']);
254			}
255
256			/**
257			* @return void
258			*
259			* @runInSeparateProcess
260			*/
261			public function testUpdateWithEmptySlug() : void
262			{
263			$container = $this->getContainer();
264			$doctrine = $container->get('doctrine');
265
266			$entityManager = $doctrine->getManager('master');
267			$this->createDatabaseSchema($entityManager);
268
269			$entryManager = $container->get('entryManager');
270			// the database MUST be empty...
271			$this->assertSame(0, $entryManager->countAll());
272
273			$foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
274
275			$this->expectException(InvalidEntityException::class);
276			$entryManager->update($foo, ['name' => 'bar', 'slug' => '']);
277			}
278
279			/**
280			* @return void
281			*
282			* @runInSeparateProcess
283			*/
284			public function testUpdateWithNotUniqueSlug() : void
285			{
286			$container = $this->getContainer();
287			$doctrine = $container->get('doctrine');
288
289			$entityManager = $doctrine->getManager('master');
290			$this->createDatabaseSchema($entityManager);
291
292			$entryManager = $container->get('entryManager');
293			// the database MUST be empty...
294			$this->assertSame(0, $entryManager->countAll());
295
296			$foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
297			$bar = $entryManager->create(['name' => 'bar', 'slug' => 'bar']);
			0 ignored issues – show Unused Code introduced 2021-02-06 08:42 UTC by Report Bug Copy Issue Report The assignment to `$bar` is dead and can be removed. Loading history...
298
299			$this->expectException(InvalidEntityException::class);
300			$entryManager->update($foo, ['name' => 'baz', 'slug' => 'bar']);
301			}
302
303			/**
304			* @return void
305			*
306			* @runInSeparateProcess
307			*/
308			public function testDelete() : void
309			{
310			$container = $this->getContainer();
311			$doctrine = $container->get('doctrine');
312
313			$entityManager = $doctrine->getManager('master');
314			$this->createDatabaseSchema($entityManager);
315
316			$entryManager = $container->get('entryManager');
317			// the database MUST be empty...
318			$this->assertSame(0, $entryManager->countAll());
319
320			$foo = $entryManager->create(['name' => 'foo', 'slug' => 'foo']);
321			$entryManager->delete($foo);
322
323			$this->expectException(EntityNotFoundException::class);
324			$entryManager->findById($foo->getId()->toString());
325			}
326			}
327

sunrise-php / awesome-skeleton

Pull Request — master (#10)

EntryManagerTest::testCountAll() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like