ResourceLinkageTest::assertResourceIdentifierCollectionEqualsFailedProvider() - Code Metrics - Inspection of "Ignore archives" - VGirol/JsonApi-Assert-Laravel - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( fae453...efb6a4 )

by Vincent

created 2019-09-21 21:27 UTC

ResourceLinkageTest::assertResourceIdentifierCollectionEqualsFailedProvider() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	26
Code Lines	19

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	19
c	0
b	0
f	0
dl	0
loc	26
rs	9.6333
cc	1
nc	1
nop	0

<?php
namespace VGirol\JsonApiAssert\Laravel\Tests\Asserts\Structure;

use Illuminate\Support\Collection;
use VGirol\JsonApiAssert\Laravel\Assert;
use VGirol\JsonApiAssert\Laravel\Tests\TestCase;
use VGirol\JsonApiAssert\Laravel\Tests\Tools\Models\ModelForTest;
use VGirol\JsonApiAssert\Messages;

class ResourceLinkageTest extends TestCase
{
    /**
     * @test
     */
    public function assertResourceIdentifierEqualsModel()
    {
        $id = 10;
        $attributes = [
            'TST_ID' => $id,
            'TST_NAME' => 'test',
            'TST_NUMBER' => 123,
            'TST_CREATION_DATE' => null
        ];

        $model = new ModelForTest();
        $model->setRawAttributes($attributes);

        $resource = [
            'type' => $model->getResourceType(),
            'id' => strval($id),
        ];

        Assert::assertResourceIdentifierEqualsModel($model, $model->getResourceType(), $resource);
    }

    /**
     * @test
     * @dataProvider assertResourceIdentifierEqualsModelFailedProvider
     */
    public function assertResourceIdentifierEqualsModelFailed($model, $resource, $failureMsg)
    {
        $this->setFailureException($failureMsg);

        Assert::assertResourceIdentifierEqualsModel($model, $model->getResourceType(), $resource);
    }

    public function assertResourceIdentifierEqualsModelFailedProvider()
    {
        $id = 10;
        $attributes = [
            'TST_ID' => $id,
            'TST_NAME' => 'test',
            'TST_NUMBER' => 123,
            'TST_CREATION_DATE' => null
        ];

        $model = new ModelForTest();
        $model->setRawAttributes($attributes);

        return [
            'not same type' => [
                $model,
                [
                    'type' => 'wrong',
                    'id' => $id
                ],
                null
            ],
            'not same id' => [
                $model,
                [
                    'type' => $model->getResourceType(),
                    'id' => $id + 2
                ],
                null
            ]
        ];
    }

    /**
     * @test
     */
    public function assertResourceIdentifierCollectionEquals()
    {
        $refCollection = $this->createCollection();
        $collection = $this->createResourceCollection($refCollection, true, false);
        $resourceType = $refCollection[0]->getResourceType();

        Assert::assertResourceIdentifierCollectionEqualsCollection($refCollection, $resourceType, $collection);
    }

    /**
     * @test
     */
    public function assertResourceIdentifierCollectionEqualsInvalidArguments()
    {
        $ref = [];
        $this->setInvalidArgumentException(1, Collection::class, $ref);
        Assert::assertResourceIdentifierCollectionEquals($ref, 'test', []);
    }

    /**
     * @test
     * @dataProvider assertResourceIdentifierCollectionEqualsFailedProvider
     */
    public function assertResourceIdentifierCollectionEqualsFailed(
        $refCollection,
        $resourceType,
        $collection,
        $failureMsg
    ) {
        $this->setFailureException($failureMsg);

        Assert::assertResourceIdentifierCollectionEquals($refCollection, $resourceType, $collection);
    }

    public function assertResourceIdentifierCollectionEqualsFailedProvider()
    {
        $refCollection = $this->createCollection();
        $collection = $this->createResourceCollection($refCollection, true, true);
        $resourceType = $refCollection[0]->getResourceType();

        return [
            'resource identifier collection is not an array of objects' => [
                $refCollection,
                $resourceType,
                $collection[0],
                Messages::MUST_BE_ARRAY_OF_OBJECTS
            ],
            'resource linkage has not the expected count' => [
                $refCollection,
                $resourceType,
                [
                    $collection[0]
                ],
                null
            ],
            'resource linkage is not as expected' => [
                $refCollection,
                $resourceType,
                $collection,
                null
            ]
        ];
    }

    /**
     * @test
     * @dataProvider assertResourceLinkageEqualsProvider
     */
    public function assertResourceLinkageEquals($reference, $resourceType, $resLinkage, $strict)
    {
        Assert::assertResourceLinkageEquals($reference, $resourceType, $resLinkage, $strict);
    }

    public function assertResourceLinkageEqualsProvider()
    {
        $model = $this->createModel(0);
        $resourceType = $model->getResourceType();
        $collection = $this->createCollection();

        return [
            'resource linkage is null' => [
                null,
                $resourceType,
                null,
                false
            ],
            'resource linkage is a single resource identifier' => [
                $this->createModel(0),
                $resourceType,
                [
                    'type' => $resourceType,
                    'id' => strval($model->getKey())
                ],
                false
            ],
            'resource linkage is an empty array' => [
                new Collection,
                $resourceType,
                [],
                false
            ],
            'resource linkage is a collection of 1 item' => [
                new Collection([$model]),
                $resourceType,
                $this->createResourceCollection(new Collection([$model]), true, false),
                false
            ],
            'resource linkage is a collection' => [
                $collection,
                $resourceType,
                $this->createResourceCollection($collection, true, false),
                false
            ]
        ];
    }

    /**
     * @test
     * @dataProvider assertResourceLinkageEqualsFailedProvider
     */
    public function assertResourceLinkageEqualsFailed($reference, $resourceType, $resLinkage, $strict, $failureMsg)
    {
        $this->setFailureException($failureMsg);

        Assert::assertResourceLinkageEquals($reference, $resourceType, $resLinkage, $strict);
    }

    public function assertResourceLinkageEqualsFailedProvider()
    {
        $model = $this->createModel(0);
        $resourceType = $model->getResourceType();
        $collection = $this->createCollection();

        return [
            'resource linkage is not valid' => [
                $collection,
                $resourceType,
                [
                    'type' => $resourceType,
                    'id' => 10
                ],
                false,
                Messages::RESOURCE_ID_MEMBER_IS_NOT_STRING
            ],
            'resource linkage is not null' => [
                null,
                $resourceType,
                [
                    'type' => $resourceType,
                    'id' => '10'
                ],
                false,
                null
            ],
            'resource linkage is array of objects' => [
                $model,
                $resourceType,
                [
                    [
                        'type' => $resourceType,
                        'id' => '10'
                    ],
                    [
                        'type' => $resourceType,
                        'id' => '12'
                    ]
                ],
                false,
                Messages::MUST_NOT_BE_ARRAY_OF_OBJECTS
            ],
            'resource linkage is not as expected' => [
                $model,
                $resourceType,
                [
                    'type' => $resourceType,
                    'id' => strval($model->getKey() + 1)
                ],
                false,
                null
            ],
            'resource linkage is not an empty array' => [
                new Collection,
                $resourceType,
                [
                    [
                        'type' => $resourceType,
                        'id' => '10'
                    ]
                ],
                false,
                null
            ],
            'resource linkage is not the expected collection' => [
                $collection,
                $resourceType,
                $this->createResourceCollection($collection, true, true),
                false,
                null
            ]
        ];
    }
}


1			<?php
2			namespace VGirol\JsonApiAssert\Laravel\Tests\Asserts\Structure;
3
4			use Illuminate\Support\Collection;
5			use VGirol\JsonApiAssert\Laravel\Assert;
6			use VGirol\JsonApiAssert\Laravel\Tests\TestCase;
7			use VGirol\JsonApiAssert\Laravel\Tests\Tools\Models\ModelForTest;
8			use VGirol\JsonApiAssert\Messages;
9
10			class ResourceLinkageTest extends TestCase
11			{
12			/**
13			* @test
14			*/
15			public function assertResourceIdentifierEqualsModel()
16			{
17			$id = 10;
18			$attributes = [
19			'TST_ID' => $id,
20			'TST_NAME' => 'test',
21			'TST_NUMBER' => 123,
22			'TST_CREATION_DATE' => null
23			];
24
25			$model = new ModelForTest();
26			$model->setRawAttributes($attributes);
27
28			$resource = [
29			'type' => $model->getResourceType(),
30			'id' => strval($id),
31			];
32
33			Assert::assertResourceIdentifierEqualsModel($model, $model->getResourceType(), $resource);
34			}
35
36			/**
37			* @test
38			* @dataProvider assertResourceIdentifierEqualsModelFailedProvider
39			*/
40			public function assertResourceIdentifierEqualsModelFailed($model, $resource, $failureMsg)
41			{
42			$this->setFailureException($failureMsg);
43
44			Assert::assertResourceIdentifierEqualsModel($model, $model->getResourceType(), $resource);
45			}
46
47			public function assertResourceIdentifierEqualsModelFailedProvider()
48			{
49			$id = 10;
50			$attributes = [
51			'TST_ID' => $id,
52			'TST_NAME' => 'test',
53			'TST_NUMBER' => 123,
54			'TST_CREATION_DATE' => null
55			];
56
57			$model = new ModelForTest();
58			$model->setRawAttributes($attributes);
59
60			return [
61			'not same type' => [
62			$model,
63			[
64			'type' => 'wrong',
65			'id' => $id
66			],
67			null
68			],
69			'not same id' => [
70			$model,
71			[
72			'type' => $model->getResourceType(),
73			'id' => $id + 2
74			],
75			null
76			]
77			];
78			}
79
80			/**
81			* @test
82			*/
83			public function assertResourceIdentifierCollectionEquals()
84			{
85			$refCollection = $this->createCollection();
86			$collection = $this->createResourceCollection($refCollection, true, false);
87			$resourceType = $refCollection[0]->getResourceType();
88
89			Assert::assertResourceIdentifierCollectionEqualsCollection($refCollection, $resourceType, $collection);
90			}
91
92			/**
93			* @test
94			*/
95			public function assertResourceIdentifierCollectionEqualsInvalidArguments()
96			{
97			$ref = [];
98			$this->setInvalidArgumentException(1, Collection::class, $ref);
99			Assert::assertResourceIdentifierCollectionEquals($ref, 'test', []);
100			}
101
102			/**
103			* @test
104			* @dataProvider assertResourceIdentifierCollectionEqualsFailedProvider
105			*/
106			public function assertResourceIdentifierCollectionEqualsFailed(
107			$refCollection,
108			$resourceType,
109			$collection,
110			$failureMsg
111			) {
112			$this->setFailureException($failureMsg);
113
114			Assert::assertResourceIdentifierCollectionEquals($refCollection, $resourceType, $collection);
115			}
116
117			public function assertResourceIdentifierCollectionEqualsFailedProvider()
118			{
119			$refCollection = $this->createCollection();
120			$collection = $this->createResourceCollection($refCollection, true, true);
121			$resourceType = $refCollection[0]->getResourceType();
122
123			return [
124			'resource identifier collection is not an array of objects' => [
125			$refCollection,
126			$resourceType,
127			$collection[0],
128			Messages::MUST_BE_ARRAY_OF_OBJECTS
129			],
130			'resource linkage has not the expected count' => [
131			$refCollection,
132			$resourceType,
133			[
134			$collection[0]
135			],
136			null
137			],
138			'resource linkage is not as expected' => [
139			$refCollection,
140			$resourceType,
141			$collection,
142			null
143			]
144			];
145			}
146
147			/**
148			* @test
149			* @dataProvider assertResourceLinkageEqualsProvider
150			*/
151			public function assertResourceLinkageEquals($reference, $resourceType, $resLinkage, $strict)
152			{
153			Assert::assertResourceLinkageEquals($reference, $resourceType, $resLinkage, $strict);
154			}
155
156			public function assertResourceLinkageEqualsProvider()
157			{
158			$model = $this->createModel(0);
159			$resourceType = $model->getResourceType();
160			$collection = $this->createCollection();
161
162			return [
163			'resource linkage is null' => [
164			null,
165			$resourceType,
166			null,
167			false
168			],
169			'resource linkage is a single resource identifier' => [
170			$this->createModel(0),
171			$resourceType,
172			[
173			'type' => $resourceType,
174			'id' => strval($model->getKey())
175			],
176			false
177			],
178			'resource linkage is an empty array' => [
179			new Collection,
180			$resourceType,
181			[],
182			false
183			],
184			'resource linkage is a collection of 1 item' => [
185			new Collection([$model]),
186			$resourceType,
187			$this->createResourceCollection(new Collection([$model]), true, false),
188			false
189			],
190			'resource linkage is a collection' => [
191			$collection,
192			$resourceType,
193			$this->createResourceCollection($collection, true, false),
194			false
195			]
196			];
197			}
198
199			/**
200			* @test
201			* @dataProvider assertResourceLinkageEqualsFailedProvider
202			*/
203			public function assertResourceLinkageEqualsFailed($reference, $resourceType, $resLinkage, $strict, $failureMsg)
204			{
205			$this->setFailureException($failureMsg);
206
207			Assert::assertResourceLinkageEquals($reference, $resourceType, $resLinkage, $strict);
208			}
209
210			public function assertResourceLinkageEqualsFailedProvider()
211			{
212			$model = $this->createModel(0);
213			$resourceType = $model->getResourceType();
214			$collection = $this->createCollection();
215
216			return [
217			'resource linkage is not valid' => [
218			$collection,
219			$resourceType,
220			[
221			'type' => $resourceType,
222			'id' => 10
223			],
224			false,
225			Messages::RESOURCE_ID_MEMBER_IS_NOT_STRING
226			],
227			'resource linkage is not null' => [
228			null,
229			$resourceType,
230			[
231			'type' => $resourceType,
232			'id' => '10'
233			],
234			false,
235			null
236			],
237			'resource linkage is array of objects' => [
238			$model,
239			$resourceType,
240			[
241			[
242			'type' => $resourceType,
243			'id' => '10'
244			],
245			[
246			'type' => $resourceType,
247			'id' => '12'
248			]
249			],
250			false,
251			Messages::MUST_NOT_BE_ARRAY_OF_OBJECTS
252			],
253			'resource linkage is not as expected' => [
254			$model,
255			$resourceType,
256			[
257			'type' => $resourceType,
258			'id' => strval($model->getKey() + 1)
259			],
260			false,
261			null
262			],
263			'resource linkage is not an empty array' => [
264			new Collection,
265			$resourceType,
266			[
267			[
268			'type' => $resourceType,
269			'id' => '10'
270			]
271			],
272			false,
273			null
274			],
275			'resource linkage is not the expected collection' => [
276			$collection,
277			$resourceType,
278			$this->createResourceCollection($collection, true, true),
279			false,
280			null
281			]
282			];
283			}
284			}
285

VGirol / JsonApi-Assert-Laravel

Push — master ( fae453...efb6a4 )

ResourceLinkageTest::assertResourceIdentifierCollectionEqualsFailedProvider() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like