CrudPanelCreateTest::testCreateWithOneToOneRelationship() - Code Metrics - Inspection of "[4.1] BelongsTo relation save with main item" - Laravel-Backpack/CRUD - Measure and Improve Code Quality continuously with Scrutinizer

Test Setup Failed

Pull Request — master (#3250)

unknown

created 2020-12-08 18:32 UTC

testCreateWithOneToOneRelationship() A

↳ Parent: CrudPanelCreateTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	17
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	13
nc	1
nop	0
dl	0
loc	17
rs	9.8333
c	0
b	0
f	0

<?php

namespace Backpack\CRUD\Tests\Unit\CrudPanel;

use Backpack\CRUD\Tests\Unit\Models\Address;
use Backpack\CRUD\Tests\Unit\Models\Article;
use Backpack\CRUD\Tests\Unit\Models\User;
use Faker\Factory;
use Illuminate\Support\Arr;

class CrudPanelCreateTest extends BaseDBCrudPanelTest
{
    private $nonRelationshipField = [
        'name'  => 'field1',
        'label' => 'Field1',
    ];

    private $userInputFieldsNoRelationships = [
        [
            'name' => 'id',
            'type' => 'hidden',
        ], [
            'name' => 'name',
        ], [
            'name' => 'email',
            'type' => 'email',
        ], [
            'name' => 'password',
            'type' => 'password',
        ],
    ];

    private $articleInputFieldsOneToMany = [
        [
            'name' => 'id',
            'type' => 'hidden',
        ], [
            'name' => 'content',
        ], [
            'name' => 'tags',
        ], [
            'label'     => 'Author',
            'type'      => 'select',
            'name'      => 'user_id',
            'entity'    => 'user',
            'attribute' => 'name',
        ],
    ];

    private $userInputFieldsManyToMany = [
        [
            'name' => 'id',
            'type' => 'hidden',
        ], [
            'name' => 'name',
        ], [
            'name' => 'email',
            'type' => 'email',
        ], [
            'name' => 'password',
            'type' => 'password',
        ], [
            'label'     => 'Roles',
            'type'      => 'select_multiple',
            'name'      => 'roles',
            'entity'    => 'roles',
            'attribute' => 'name',
            'pivot'     => true,
        ],
    ];

    private $userInputFieldsDotNotation = [
        [
            'name' => 'id',
            'type' => 'hidden',
        ], [
            'name' => 'name',
        ], [
            'name' => 'email',
            'type' => 'email',
        ], [
            'name' => 'password',
            'type' => 'password',
        ], [
            'label'     => 'Roles',
            'type'      => 'relationship',
            'name'      => 'roles',
            'entity'    => 'roles',
            'attribute' => 'name',
        ], [
            'label'     => 'Street',
            'name'      => 'street',
            'entity'    => 'accountDetails.addresses',
            'attribute' => 'street',
        ],
    ];

    private $userInputHasOneRelation = [
        [
            'name' => 'accountDetails.nickname',
        ],
        [
            'name' => 'accountDetails.profile_picture',
        ],
    ];

    private $articleBelongsToWithRelationName = [
        [
            'name' => 'user',
            'type' => 'relationship',
        ],
        [
            'name' => 'address',
            'type' => 'relationship',
        ],
        [
            'name' => 'content',
        ],

    ];

    private $articleBelongsToWithRelatedKey = [
        [
            'name' => 'user_id',
            'type' => 'relationship',
        ],
        [
            'name' => 'address_id',
            'type' => 'relationship',
        ],
        [
            'name' => 'content',
        ],

    ];

    public function testCreate()
    {
        $this->crudPanel->setModel(User::class);
        $this->crudPanel->addFields($this->userInputFieldsNoRelationships);
        $faker = Factory::create();
        $inputData = [
            'name'     => $faker->name,
            'email'    => $faker->safeEmail,
            'password' => bcrypt($faker->password()),
        ];

        $entry = $this->crudPanel->create($inputData);

        $this->assertInstanceOf(User::class, $entry);
        $this->assertEntryEquals($inputData, $entry);
        $this->assertEmpty($entry->articles);
    }

    public function testCreateBelongsToWithRelationName()
    {
        $this->crudPanel->setModel(Article::class);
        $this->crudPanel->addFields($this->articleBelongsToWithRelationName);
        $faker = Factory::create();
        $inputData = [
            'user'     => 1,
            'content'    => $faker->text,
            'address' => 1,
        ];

        $entry = $this->crudPanel->create($inputData);

        $this->assertInstanceOf(Address::class, $entry->address);
        $this->assertInstanceOf(User::class, $entry->user);
    }

    public function testCreateBelongsToWithRelationKey()
    {
        $this->crudPanel->setModel(Article::class);
        $this->crudPanel->addFields($this->articleBelongsToWithRelatedKey);
        $faker = Factory::create();
        $inputData = [
            'user_id'     => 1,
            'content'    => $faker->text,
            'address_id' => 1,
        ];

        $entry = $this->crudPanel->create($inputData);

        $this->assertInstanceOf(Address::class, $entry->address);
        $this->assertInstanceOf(User::class, $entry->user);
    }

    public function testCreateWithOneToOneRelationship()
    {
        $this->crudPanel->setModel(User::class);
        $this->crudPanel->addFields($this->userInputFieldsNoRelationships);
        $this->crudPanel->addFields($this->userInputHasOneRelation);
        $faker = Factory::create();
        $inputData = [
            'name'     => $faker->name,
            'email'    => $faker->safeEmail,
            'password' => bcrypt($faker->password()),
            'accountDetails' => [
                'nickname' => $faker->name,
                'profile_picture' => 'test.jpg',
            ],
        ];
        $entry = $this->crudPanel->create($inputData);

        $this->markTestIncomplete('Has one relation is not created in tests.');
    }

    public function testCreateWithOneToManyRelationship()
    {
        $this->crudPanel->setModel(Article::class);
        $this->crudPanel->addFields($this->articleInputFieldsOneToMany);
        $faker = Factory::create();
        $inputData = [
            'content'     => $faker->text(),
            'tags'        => $faker->words(3, true),
            'user_id'     => 1,
            'metas'       => null,
            'extras'      => null,
            'cast_metas'  => null,
            'cast_tags'   => null,
            'cast_extras' => null,
        ];

        $entry = $this->crudPanel->create($inputData);
        $userEntry = User::find(1);

        $article = Article::where('user_id', 1)->with('user')->get()->last();
        $this->assertEntryEquals($inputData, $entry);
        $this->assertEquals($article->user_id, $entry->user_id);
        $this->assertEquals($article->id, $entry->id);
    }

    public function testCreateWithManyToManyRelationship()
    {
        $this->crudPanel->setModel(User::class);
        $this->crudPanel->addFields($this->userInputFieldsManyToMany);
        $faker = Factory::create();
        $inputData = [
            'name'           => $faker->name,
            'email'          => $faker->safeEmail,
            'password'       => bcrypt($faker->password()),
            'remember_token' => null,
            'roles'          => [1, 2],
        ];

        $entry = $this->crudPanel->create($inputData);

        $this->assertInstanceOf(User::class, $entry);
        $this->assertEntryEquals($inputData, $entry);
    }

    public function testGetRelationFields()
    {
        $this->markTestIncomplete('Not correctly implemented');

        $this->crudPanel->setModel(User::class);
        $this->crudPanel->addFields($this->userInputFieldsManyToMany, 'create');

        // TODO: fix method and documentation. when 'both' is passed as the $form value, the getRelationFields searches
        //       for relationship fields in the update fields.
        $relationFields = $this->crudPanel->getRelationFields('both');

        $this->assertEquals($this->crudPanel->create_fields['roles'], Arr::last($relationFields));
    }

    public function testGetRelationFieldsCreateForm()
    {
        $this->crudPanel->setModel(User::class);
        $this->crudPanel->setOperation('create');
        $this->crudPanel->addFields($this->userInputFieldsManyToMany);

        $relationFields = $this->crudPanel->getRelationFields();

        $this->assertEquals($this->crudPanel->get('create.fields')['roles'], Arr::last($relationFields));
    }

    public function testGetRelationFieldsUpdateForm()
    {
        $this->crudPanel->setModel(User::class);
        $this->crudPanel->setOperation('update');
        $this->crudPanel->addFields($this->userInputFieldsManyToMany);

        $relationFields = $this->crudPanel->getRelationFields();

        $this->assertEquals($this->crudPanel->get('update.fields')['roles'], Arr::last($relationFields));
    }

    public function testGetRelationFieldsUnknownForm()
    {
        $this->markTestIncomplete('Not correctly implemented');

        $this->expectException(\InvalidArgumentException::class);

        $this->crudPanel->setModel(User::class);
        $this->crudPanel->addFields($this->userInputFieldsManyToMany);

        // TODO: this should throw an invalid argument exception but instead it searches for relationship fields in the
        //       update fields.
        $this->crudPanel->getRelationFields('unknownForm');
    }

    public function testGetRelationFieldsDotNotation()
    {
        $this->crudPanel->setModel(User::class);
        $this->crudPanel->setOperation('create');

        $this->crudPanel->addFields($this->userInputFieldsDotNotation);

        //get all fields with a relation
        $relationFields = $this->crudPanel->getRelationFields();
        //var_dump($this->crudPanel->get('create.fields')['street']);

        $this->assertEquals($this->crudPanel->get('create.fields')['street'], Arr::last($relationFields));
    }

    public function testCreateHasOneRelations()
    {
        $this->crudPanel->setModel(User::class);
        $this->crudPanel->setOperation('create');

        $this->crudPanel->addFields($this->userInputHasOneRelation);
        $faker = Factory::create();

        $inputData = [
            'name'           => $faker->name,
            'email'          => $faker->safeEmail,
            'password'       => bcrypt($faker->password()),
            'remember_token' => null,
            'roles'          => [1, 2],
            'accountDetails' => [
                'nickname' => 'i_have_has_one',
                'profile_picture' => 'simple_picture.jpg',
            ],
        ];
        $entry = $this->crudPanel->create($inputData);
        $account_details = $entry->accountDetails()->first();

        $this->assertEquals($account_details->nickname, 'i_have_has_one');
    }

    public function testGetRelationFieldsNoRelations()
    {
        $this->crudPanel->addField($this->nonRelationshipField);

        $relationFields = $this->crudPanel->getRelationFields();

        $this->assertEmpty($relationFields);
    }

    public function testGetRelationFieldsNoFields()
    {
        $relationFields = $this->crudPanel->getRelationFields();

        $this->assertEmpty($relationFields);
    }

    public function testGetRelationFieldsWithPivot()
    {
        $this->crudPanel->setModel(User::class);
        $this->crudPanel->setOperation('create');
        $this->crudPanel->addFields($this->userInputFieldsDotNotation);

        $relationFields = $this->crudPanel->getRelationFieldsWithPivot();
        $this->assertEquals($this->crudPanel->get('create.fields')['roles'], Arr::first($relationFields));
    }

    public function testGetRelationFieldsWithPivotNoRelations()
    {
        $this->crudPanel->setModel(User::class);
        $this->crudPanel->setOperation('create');
        $this->crudPanel->addFields($this->nonRelationshipField);

        $relationFields = $this->crudPanel->getRelationFieldsWithPivot();

        $this->assertEmpty($relationFields);
    }

    public function testCreateOneToOneRelationships()
    {
    }

    public function testSyncPivot()
    {
        $this->crudPanel->setModel(User::class);
        $this->crudPanel->addFields($this->userInputFieldsManyToMany);
        $faker = Factory::create();
        $inputData = [
            'name'           => $faker->name,
            'email'          => $faker->safeEmail,
            'password'       => bcrypt($faker->password()),
            'remember_token' => null,
            'roles'          => [1, 2],
        ];

        $entry = User::find(1);
        $this->crudPanel->syncPivot($entry, $inputData);

        $this->assertEquals($inputData['roles'], $entry->roles->pluck('id')->toArray());
    }

    public function testSyncPivotUnknownData()
    {
        $this->crudPanel->setModel(User::class);
        $this->crudPanel->addFields($this->nonRelationshipField);
        $faker = Factory::create();
        $inputData = [
            'name'           => $faker->name,
            'email'          => $faker->safeEmail,
            'password'       => bcrypt($faker->password()),
            'remember_token' => null,
            'roles'          => [1, 2],
        ];

        $entry = User::find(1);
        $this->crudPanel->syncPivot($entry, $inputData);

        $this->assertEquals(1, $entry->roles->count());
    }

    public function testSyncPivotUnknownModel()
    {
        $this->expectException(\BadMethodCallException::class);

        $this->crudPanel->setModel(User::class);
        $this->crudPanel->addFields($this->userInputFieldsManyToMany);
        $faker = Factory::create();
        $inputData = [
            'name'           => $faker->name,
            'email'          => $faker->safeEmail,
            'password'       => bcrypt($faker->password()),
            'remember_token' => null,
            'roles'          => [1, 2],
        ];

        $entry = Article::find(1);
        $this->crudPanel->syncPivot($entry, $inputData);
    }
}


1			<?php
2
3			namespace Backpack\CRUD\Tests\Unit\CrudPanel;
4
5			use Backpack\CRUD\Tests\Unit\Models\Address;
6			use Backpack\CRUD\Tests\Unit\Models\Article;
7			use Backpack\CRUD\Tests\Unit\Models\User;
8			use Faker\Factory;
9			use Illuminate\Support\Arr;
10
11			class CrudPanelCreateTest extends BaseDBCrudPanelTest
12			{
13			private $nonRelationshipField = [
14			'name' => 'field1',
15			'label' => 'Field1',
16			];
17
18			private $userInputFieldsNoRelationships = [
19			[
20			'name' => 'id',
21			'type' => 'hidden',
22			], [
23			'name' => 'name',
24			], [
25			'name' => 'email',
26			'type' => 'email',
27			], [
28			'name' => 'password',
29			'type' => 'password',
30			],
31			];
32
33			private $articleInputFieldsOneToMany = [
34			[
35			'name' => 'id',
36			'type' => 'hidden',
37			], [
38			'name' => 'content',
39			], [
40			'name' => 'tags',
41			], [
42			'label' => 'Author',
43			'type' => 'select',
44			'name' => 'user_id',
45			'entity' => 'user',
46			'attribute' => 'name',
47			],
48			];
49
50			private $userInputFieldsManyToMany = [
51			[
52			'name' => 'id',
53			'type' => 'hidden',
54			], [
55			'name' => 'name',
56			], [
57			'name' => 'email',
58			'type' => 'email',
59			], [
60			'name' => 'password',
61			'type' => 'password',
62			], [
63			'label' => 'Roles',
64			'type' => 'select_multiple',
65			'name' => 'roles',
66			'entity' => 'roles',
67			'attribute' => 'name',
68			'pivot' => true,
69			],
70			];
71
72			private $userInputFieldsDotNotation = [
73			[
74			'name' => 'id',
75			'type' => 'hidden',
76			], [
77			'name' => 'name',
78			], [
79			'name' => 'email',
80			'type' => 'email',
81			], [
82			'name' => 'password',
83			'type' => 'password',
84			], [
85			'label' => 'Roles',
86			'type' => 'relationship',
87			'name' => 'roles',
88			'entity' => 'roles',
89			'attribute' => 'name',
90			], [
91			'label' => 'Street',
92			'name' => 'street',
93			'entity' => 'accountDetails.addresses',
94			'attribute' => 'street',
95			],
96			];
97
98			private $userInputHasOneRelation = [
99			[
100			'name' => 'accountDetails.nickname',
101			],
102			[
103			'name' => 'accountDetails.profile_picture',
104			],
105			];
106
107			private $articleBelongsToWithRelationName = [
108			[
109			'name' => 'user',
110			'type' => 'relationship',
111			],
112			[
113			'name' => 'address',
114			'type' => 'relationship',
115			],
116			[
117			'name' => 'content',
118			],
119
120			];
121
122			private $articleBelongsToWithRelatedKey = [
123			[
124			'name' => 'user_id',
125			'type' => 'relationship',
126			],
127			[
128			'name' => 'address_id',
129			'type' => 'relationship',
130			],
131			[
132			'name' => 'content',
133			],
134
135			];
136
137			public function testCreate()
138			{
139			$this->crudPanel->setModel(User::class);
140			$this->crudPanel->addFields($this->userInputFieldsNoRelationships);
141			$faker = Factory::create();
142			$inputData = [
143			'name' => $faker->name,
144			'email' => $faker->safeEmail,
145			'password' => bcrypt($faker->password()),
146			];
147
148			$entry = $this->crudPanel->create($inputData);
149
150			$this->assertInstanceOf(User::class, $entry);
151			$this->assertEntryEquals($inputData, $entry);
152			$this->assertEmpty($entry->articles);
153			}
154
155			public function testCreateBelongsToWithRelationName()
156			{
157			$this->crudPanel->setModel(Article::class);
158			$this->crudPanel->addFields($this->articleBelongsToWithRelationName);
159			$faker = Factory::create();
160			$inputData = [
161			'user' => 1,
162			'content' => $faker->text,
163			'address' => 1,
164			];
165
166			$entry = $this->crudPanel->create($inputData);
167
168			$this->assertInstanceOf(Address::class, $entry->address);
169			$this->assertInstanceOf(User::class, $entry->user);
170			}
171
172			public function testCreateBelongsToWithRelationKey()
173			{
174			$this->crudPanel->setModel(Article::class);
175			$this->crudPanel->addFields($this->articleBelongsToWithRelatedKey);
176			$faker = Factory::create();
177			$inputData = [
178			'user_id' => 1,
179			'content' => $faker->text,
180			'address_id' => 1,
181			];
182
183			$entry = $this->crudPanel->create($inputData);
184
185			$this->assertInstanceOf(Address::class, $entry->address);
186			$this->assertInstanceOf(User::class, $entry->user);
187			}
188
189			public function testCreateWithOneToOneRelationship()
190			{
191			$this->crudPanel->setModel(User::class);
192			$this->crudPanel->addFields($this->userInputFieldsNoRelationships);
193			$this->crudPanel->addFields($this->userInputHasOneRelation);
194			$faker = Factory::create();
195			$inputData = [
196			'name' => $faker->name,
197			'email' => $faker->safeEmail,
198			'password' => bcrypt($faker->password()),
199			'accountDetails' => [
200			'nickname' => $faker->name,
201			'profile_picture' => 'test.jpg',
202			],
203			];
204			$entry = $this->crudPanel->create($inputData);
			0 ignored issues – show Unused Code introduced 2020-05-15 14:07 UTC by Report Bug Copy Issue Report The assignment to `$entry` is dead and can be removed. Loading history...
205			$this->markTestIncomplete('Has one relation is not created in tests.');
206			}
207
208			public function testCreateWithOneToManyRelationship()
209			{
210			$this->crudPanel->setModel(Article::class);
211			$this->crudPanel->addFields($this->articleInputFieldsOneToMany);
212			$faker = Factory::create();
213			$inputData = [
214			'content' => $faker->text(),
215			'tags' => $faker->words(3, true),
216			'user_id' => 1,
217			'metas' => null,
218			'extras' => null,
219			'cast_metas' => null,
220			'cast_tags' => null,
221			'cast_extras' => null,
222			];
223
224			$entry = $this->crudPanel->create($inputData);
225			$userEntry = User::find(1);
			0 ignored issues – show Unused Code introduced 2020-03-16 09:46 UTC by Report Bug Copy Issue Report The assignment to `$userEntry` is dead and can be removed. Loading history...
226			$article = Article::where('user_id', 1)->with('user')->get()->last();
227			$this->assertEntryEquals($inputData, $entry);
228			$this->assertEquals($article->user_id, $entry->user_id);
229			$this->assertEquals($article->id, $entry->id);
230			}
231
232			public function testCreateWithManyToManyRelationship()
233			{
234			$this->crudPanel->setModel(User::class);
235			$this->crudPanel->addFields($this->userInputFieldsManyToMany);
236			$faker = Factory::create();
237			$inputData = [
238			'name' => $faker->name,
239			'email' => $faker->safeEmail,
240			'password' => bcrypt($faker->password()),
241			'remember_token' => null,
242			'roles' => [1, 2],
243			];
244
245			$entry = $this->crudPanel->create($inputData);
246
247			$this->assertInstanceOf(User::class, $entry);
248			$this->assertEntryEquals($inputData, $entry);
249			}
250
251			public function testGetRelationFields()
252			{
253			$this->markTestIncomplete('Not correctly implemented');
254
255			$this->crudPanel->setModel(User::class);
256			$this->crudPanel->addFields($this->userInputFieldsManyToMany, 'create');
257
258			// TODO: fix method and documentation. when 'both' is passed as the $form value, the getRelationFields searches
259			// for relationship fields in the update fields.
260			$relationFields = $this->crudPanel->getRelationFields('both');
261
262			$this->assertEquals($this->crudPanel->create_fields['roles'], Arr::last($relationFields));
263			}
264
265			public function testGetRelationFieldsCreateForm()
266			{
267			$this->crudPanel->setModel(User::class);
268			$this->crudPanel->setOperation('create');
269			$this->crudPanel->addFields($this->userInputFieldsManyToMany);
270
271			$relationFields = $this->crudPanel->getRelationFields();
272
273			$this->assertEquals($this->crudPanel->get('create.fields')['roles'], Arr::last($relationFields));
274			}
275
276			public function testGetRelationFieldsUpdateForm()
277			{
278			$this->crudPanel->setModel(User::class);
279			$this->crudPanel->setOperation('update');
280			$this->crudPanel->addFields($this->userInputFieldsManyToMany);
281
282			$relationFields = $this->crudPanel->getRelationFields();
283
284			$this->assertEquals($this->crudPanel->get('update.fields')['roles'], Arr::last($relationFields));
285			}
286
287			public function testGetRelationFieldsUnknownForm()
288			{
289			$this->markTestIncomplete('Not correctly implemented');
290
291			$this->expectException(\InvalidArgumentException::class);
292
293			$this->crudPanel->setModel(User::class);
294			$this->crudPanel->addFields($this->userInputFieldsManyToMany);
295
296			// TODO: this should throw an invalid argument exception but instead it searches for relationship fields in the
297			// update fields.
298			$this->crudPanel->getRelationFields('unknownForm');
299			}
300
301			public function testGetRelationFieldsDotNotation()
302			{
303			$this->crudPanel->setModel(User::class);
304			$this->crudPanel->setOperation('create');
305
306			$this->crudPanel->addFields($this->userInputFieldsDotNotation);
307
308			//get all fields with a relation
309			$relationFields = $this->crudPanel->getRelationFields();
310			//var_dump($this->crudPanel->get('create.fields')['street']);
311
312			$this->assertEquals($this->crudPanel->get('create.fields')['street'], Arr::last($relationFields));
313			}
314
315			public function testCreateHasOneRelations()
316			{
317			$this->crudPanel->setModel(User::class);
318			$this->crudPanel->setOperation('create');
319
320			$this->crudPanel->addFields($this->userInputHasOneRelation);
321			$faker = Factory::create();
322
323			$inputData = [
324			'name' => $faker->name,
325			'email' => $faker->safeEmail,
326			'password' => bcrypt($faker->password()),
327			'remember_token' => null,
328			'roles' => [1, 2],
329			'accountDetails' => [
330			'nickname' => 'i_have_has_one',
331			'profile_picture' => 'simple_picture.jpg',
332			],
333			];
334			$entry = $this->crudPanel->create($inputData);
335			$account_details = $entry->accountDetails()->first();
336
337			$this->assertEquals($account_details->nickname, 'i_have_has_one');
338			}
339
340			public function testGetRelationFieldsNoRelations()
341			{
342			$this->crudPanel->addField($this->nonRelationshipField);
343
344			$relationFields = $this->crudPanel->getRelationFields();
345
346			$this->assertEmpty($relationFields);
347			}
348
349			public function testGetRelationFieldsNoFields()
350			{
351			$relationFields = $this->crudPanel->getRelationFields();
352
353			$this->assertEmpty($relationFields);
354			}
355
356			public function testGetRelationFieldsWithPivot()
357			{
358			$this->crudPanel->setModel(User::class);
359			$this->crudPanel->setOperation('create');
360			$this->crudPanel->addFields($this->userInputFieldsDotNotation);
361
362			$relationFields = $this->crudPanel->getRelationFieldsWithPivot();
363			$this->assertEquals($this->crudPanel->get('create.fields')['roles'], Arr::first($relationFields));
364			}
365
366			public function testGetRelationFieldsWithPivotNoRelations()
367			{
368			$this->crudPanel->setModel(User::class);
369			$this->crudPanel->setOperation('create');
370			$this->crudPanel->addFields($this->nonRelationshipField);
371
372			$relationFields = $this->crudPanel->getRelationFieldsWithPivot();
373
374			$this->assertEmpty($relationFields);
375			}
376
377			public function testCreateOneToOneRelationships()
378			{
379			}
380
381			public function testSyncPivot()
382			{
383			$this->crudPanel->setModel(User::class);
384			$this->crudPanel->addFields($this->userInputFieldsManyToMany);
385			$faker = Factory::create();
386			$inputData = [
387			'name' => $faker->name,
388			'email' => $faker->safeEmail,
389			'password' => bcrypt($faker->password()),
390			'remember_token' => null,
391			'roles' => [1, 2],
392			];
393
394			$entry = User::find(1);
395			$this->crudPanel->syncPivot($entry, $inputData);
396
397			$this->assertEquals($inputData['roles'], $entry->roles->pluck('id')->toArray());
398			}
399
400			public function testSyncPivotUnknownData()
401			{
402			$this->crudPanel->setModel(User::class);
403			$this->crudPanel->addFields($this->nonRelationshipField);
404			$faker = Factory::create();
405			$inputData = [
406			'name' => $faker->name,
407			'email' => $faker->safeEmail,
408			'password' => bcrypt($faker->password()),
409			'remember_token' => null,
410			'roles' => [1, 2],
411			];
412
413			$entry = User::find(1);
414			$this->crudPanel->syncPivot($entry, $inputData);
415
416			$this->assertEquals(1, $entry->roles->count());
417			}
418
419			public function testSyncPivotUnknownModel()
420			{
421			$this->expectException(\BadMethodCallException::class);
422
423			$this->crudPanel->setModel(User::class);
424			$this->crudPanel->addFields($this->userInputFieldsManyToMany);
425			$faker = Factory::create();
426			$inputData = [
427			'name' => $faker->name,
428			'email' => $faker->safeEmail,
429			'password' => bcrypt($faker->password()),
430			'remember_token' => null,
431			'roles' => [1, 2],
432			];
433
434			$entry = Article::find(1);
435			$this->crudPanel->syncPivot($entry, $inputData);
436			}
437			}
438

Laravel-Backpack / CRUD

Scrutinizer GitHub App not installed

Pull Request — master (#3250)

testCreateWithOneToOneRelationship() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like