NamedFormElementTestModuleForTestingResolvePath - Code Metrics - Inspection of "Merge commit '269d3c1f72ae0b74def636fe5d84e4064e63..." - LaravelRUS/SleepingOwlAdmin - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b864c9...ed9166 )

by butschster

created 2017-03-11 07:55 UTC

NamedFormElementTestModuleForTestingResolvePath A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	17
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	1

Importance

Changes

Metric	Value
dl	0
loc	17
c	0
b	0
f	0
rs	10
wmc	3
lcom	0
cbo	1

<?php

use Mockery as m;
use SleepingOwl\Admin\Form\Element\NamedFormElement;

class NamedFormElementTest extends TestCase
{
    public function tearDown()
    {
        m::close();
    }

    /**
     * @param string $path
     * @param string|null $label
     *
     * @return NamedFormElement
     */
    protected function getElement($path = 'path', $label = null)
    {
        return $this->getMockForAbstractClass(NamedFormElement::class, [
            $path,
            $label,
        ]);
    }

    /**
     * @covers NamedFormElement::__constructor
     * @covers NamedFormElement::getLabel
     * @covers NamedFormElement::setLabel
     * @covers NamedFormElement::getPath
     * @covers NamedFormElement::setPath
     * @covers NamedFormElement::getName
     * @covers NamedFormElement::setName
     */
    public function test_constructor()
    {
        $element = $this->getElement($path = 'path.test.test1.tets2', $label = 'Label');

        $this->assertEquals($label, $element->getLabel());
        $this->assertEquals($path, $element->getPath());
        $this->assertEquals('path[test][test1][tets2]', $element->getName());
    }

    /**
     * @covers NamedFormElement::__constructor
     * @expectedException  \SleepingOwl\Admin\Exceptions\Form\FormElementException
     */
    public function test_constructor_exception()
    {
        $this->getElement(null);
    }

    /**
     * @covers NamedFormElement::setAttribute
     * @covers NamedFormElement::getAttribute
     */
    public function test_gets_and_sets_attribute()
    {
        $element = $this->getElement();

        $element->setModelAttributeKey('test');
        $this->assertEquals('test', $element->getModelAttributeKey());
    }

    /**
     * @covers NamedFormElement::setDefaultValue
     * @covers NamedFormElement::getDefaultValue
     */
    public function test_gets_and_sets_default_value()
    {
        $element = $this->getElement();

        $element->setDefaultValue('test');
        $this->assertEquals('test', $element->getDefaultValue());
    }

    /**
     * @covers NamedFormElement::setHelpText
     * @covers NamedFormElement::getHelpText
     */
    public function test_gets_and_sets_help_text()
    {
        $element = $this->getElement();

        $element->setHelpText('test');
        $this->assertEquals('test', $element->getHelpText());

        $helpText = m::mock(\Illuminate\Contracts\Support\Htmlable::class);
        $helpText->shouldReceive('toHtml')->once()->andReturn('html');

        $element->setHelpText($helpText);
        $this->assertEquals('html', $element->getHelpText());
    }

    /**
     * @covers NamedFormElement::required
     * @covers NamedFormElement::getValidationRules
     */
    public function test_add_required_rule()
    {
        $element = $this->getElement('key');

        $element->required();
        $this->assertEquals(['key' => ['required']], $element->getValidationRules());
    }

    /**
     * @covers NamedFormElement::required
     * @covers NamedFormElement::getValidationMessages
     */
    public function test_add_required_rule_with_message()
    {
        $element = $this->getElement('key');

        $element->required('required field');

        $this->assertEquals(['key.required' => 'required field'], $element->getValidationMessages());
    }

    /**
     * @covers NamedFormElement::required
     * @covers NamedFormElement::getValidationRules
     */
    public function test_add_unique_rule()
    {
        $element = $this->getElement('key');

        $model = m::mock(\Illuminate\Database\Eloquent\Model::class);
        $element->setModel($model);

        $model->shouldReceive('getTable')->once()->andReturn('test_table');

        $element->unique();
        $this->assertEquals(['key' => ['unique:test_table,key']], $element->getValidationRules());
    }

    /**
     * @covers NamedFormElement::unique
     * @covers NamedFormElement::getValidationMessages
     */
    public function test_add_unique_rule_with_message()
    {
        $element = $this->getElement('key');

        $element->unique('must be unique');
        $this->assertEquals(['key.unique' => 'must be unique'], $element->getValidationMessages());
    }

    /**
     * @covers NamedFormElement::addValidationMessage
     * @covers NamedFormElement::getValidationMessages
     */
    public function test_gets_validation_messages()
    {
        $element = $this->getElement('key');

        $element->addValidationMessage('test', 'test message');
        $element->addValidationMessage('hello', 'hello message');
        $this->assertEquals(['key.test' => 'test message', 'key.hello' => 'hello message'], $element->getValidationMessages());
    }

    /**
     * @covers NamedFormElement::getValidationLabels
     */
    public function test_gets_validation_labels()
    {
        $element = $this->getElement('key.subkey', 'Label');

        $this->assertEquals(['key.subkey' => 'Label'], $element->getValidationLabels());
    }

    /**
     * @covers NamedFormElement::getValueFromRequest
     */
    public function test_gets_session_value_from_request()
    {
        $request = $this->app['request'];
        $session = $request->getSession();

        $element = $this->getElement('key.subkey', 'Label');
        $session->shouldReceive('getOldInput')->andReturn('test');

        $this->assertEquals('test', $element->getValueFromRequest($request));
    }

    /**
     * @covers NamedFormElement::getValueFromRequest
     */
    public function test_gets_value_from_request()
    {
        /** @var \Illuminate\Http\Request $request */
        $request = $this->app['request'];
        $request->offsetSet('key', [
            'subkey1' => 'hello world',
        ]);

        $session = $request->getSession();

        $element = $this->getElement('key.subkey1', 'Label');
        $session->shouldReceive('getOldInput')->andReturn(null);
        $this->assertEquals('hello world', $element->getValueFromRequest($request));
    }

    /**
     * @covers NamedFormElement::getValue
     */
    public function test_gets_value_with_request()
    {
        $request = $this->app['request'];

        $session = $request->getSession();
        $session->shouldReceive('getOldInput')->andReturn(null);

        $element = $this->getElement('key.subkey', 'Label');
        $request->offsetSet('key', [
            'subkey' => 'hello world',
        ]);

        $this->assertEquals('hello world', $element->getValueFromModel());
    }

    /**
     * @covers NamedFormElement::getValue
     */
    public function test_gets_value()
    {
        $request = $this->app['request'];
        $session = $request->getSession();
        $session->shouldReceive('getOldInput')->andReturn(null);

        $element = $this->getElement('key', 'Label');

        $this->assertNull($element->getValueFromModel());

        $element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
        $model->shouldReceive('getAttribute')->with('key')->andReturn('value');

        $this->assertNull($element->getValue());

        $model->exists = true;
        $this->assertEquals('value', $element->getValueFromModel());
    }

    /**
     * @covers NamedFormElement::resolvePath
     */
    public function test_resolving_path()
    {
        $element = $this->getElement('key', 'Label');
        $element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));

        $this->assertEquals($model, $element->resolvePath());

        // -------------

        $element = $this->getElement('key.subkey', 'Label');
        $element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
        $model->exists = true;

        $model->shouldReceive('getAttribute')->andReturn($subModel = m::mock(\Illuminate\Database\Eloquent\Model::class));

        $this->assertEquals($subModel, $element->resolvePath());

        // -------------

        $element = $this->getElement('key.subkey', 'Label');
        $element->setModel($model = new NamedFormElementTestModuleForTestingResolvePath());

        $this->assertInstanceOf(NamedFormElementTestModuleForTestingResolvePathBelongsTo::class, $element->resolvePath());

        // -------------

        $element = $this->getElement('key1.subkey', 'Label');
        $element->setModel($model = new NamedFormElementTestModuleForTestingResolvePath());

        $this->assertInstanceOf(NamedFormElementTestModuleForTestingResolvePathHasOne::class, $element->resolvePath());

        // -------------

        $element = $this->getElement('key2.subkey', 'Label');
        $element->setModel($model = new NamedFormElementTestModuleForTestingResolvePath());

        $this->assertInstanceOf(NamedFormElementTestModuleForTestingResolvePathHasMany::class, $element->resolvePath());
    }

    /**
     * @covers NamedFormElement::toArray
     */
    public function test_gets_array()
    {
        $element = $this->getElement('key2.subkey', 'Label');

        $request = $this->app['request'];
        $session = $request->getSession();
        $session->shouldReceive('getOldInput')->andReturn(null);

        $this->assertEquals([
            'value' => null,
            'readonly' => false,
            'model' => null,
            'id' => 'key2[subkey]',
            'name' => 'key2[subkey]',
            'path' => 'key2.subkey',
            'label' => 'Label',
            'helpText' => null,
            'required' => false,
        ], $element->toArray());
    }

    public function test_save()
    {
        $request = $this->app['request'];

        $session = $request->getSession();
        $session->shouldReceive('getOldInput')->andReturn(null);

        $request->offsetSet($key = 'key', $value = 'hello world');
        $element = $this->getElement($key, 'Label');

        $element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
        $model->shouldReceive('setAttribute')->with('key', $value);

        $element->save($request);
    }

    public function test_sets_model_attribute()
    {
        $element = $this->getElement('key', 'Label');
        $value = 'value';

        $element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
        $model->shouldReceive('setAttribute')->with('key', $value);

        $element->setModelAttribute($value);
    }

    /**
     * @covers FormElement::isValueSkipped()
     * @covers FormElement::setValueSkipped()
     */
    public function test_does_not_set_skipped_values()
    {
        $nameElement = $this->getElement('name', 'Name');
        $passwordElement = $this->getElement('password', 'Password')->setValueSkipped(true);

        $model = new NamedFormElementTestModuleForTestingSkippedValues();
        foreach ([$nameElement, $passwordElement] as $element) {
            /* @var $element NamedFormElement  */
            $element->setModel($model);
            $element->setModelAttribute($element->getLabel());
        }

        $attributes = array_keys($model->getAttributes());
        $this->assertFalse(in_array('password', $attributes, true));
        $this->assertCount(1, $attributes);
    }

    public function test_prepare_value()
    {
        $element = $this->getElement('key', 'Label');
        $value = 'value';

        $this->assertEquals($value, $element->prepareValue($value));

        $element->mutateValue(function ($value) {
            return strtoupper($value);
        });

        $this->assertEquals('VALUE', $element->prepareValue($value));
    }

    public function test_mutator()
    {
        $element = $this->getElement('key', 'Label');
        $this->assertFalse($element->hasMutator());

        $element->mutateValue(function ($value) {
            return strtoupper($value);
        });
        $this->assertTrue($element->hasMutator());
    }

    public function test_get_model_by_path()
    {
        $element = $this->getElement('key', 'Label');

        $element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));

        $this->assertEquals($model, $this->callMethodByPath($element, 'key'));

        $element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
        $model->shouldReceive('getAttribute')->with('key')->andReturn('test');

        $this->assertNull($this->callMethodByPath($element, 'key.key1'));

        $element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
        $model->shouldReceive('getAttribute')->with('key')->andReturn(
            $model1 = m::mock(\Illuminate\Database\Eloquent\Model::class)
        );

        $this->assertEquals($model1, $this->callMethodByPath($element, 'key.key1'));
    }

    /**
     * @expectedException LogicException
     */
    public function test_get_model_by_path_exception()
    {
        $element = $this->getElement('key', 'Label');

        $element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
        $model->shouldReceive('getAttribute')->with('key')->andReturn(
            $model1 = m::mock(\Illuminate\Database\Eloquent\Model::class)
        );

        $model1->shouldReceive('getAttribute')->with('key1');

        $this->callMethodByPath($element, 'key.key1.title');
    }

    /**
     * @param NamedFormElement $element
     * @param $path
     *
     * @return mixed
     */
    protected function callMethodByPath(NamedFormElement $element, $path)
    {
        $reflection = new ReflectionClass($element);

        $method = $reflection->getMethod('getModelByPath');
        $method->setAccessible(true);

        return $method->invoke($element, $path);
    }
}

class NamedFormElementTestModuleForTestingResolvePath extends \Illuminate\Database\Eloquent\Model
{
    public function key()
    {
        return $this->hasOne(NamedFormElementTestModuleForTestingResolvePathBelongsTo::class);
    }

    public function key1()
    {
        return $this->hasOne(NamedFormElementTestModuleForTestingResolvePathHasOne::class);
    }

    public function key2()
    {
        return $this->hasMany(NamedFormElementTestModuleForTestingResolvePathHasMany::class);
    }
}

class NamedFormElementTestModuleForTestingResolvePathBelongsTo extends \Illuminate\Database\Eloquent\Model
{
}

class NamedFormElementTestModuleForTestingResolvePathHasOne extends \Illuminate\Database\Eloquent\Model
{
}

class NamedFormElementTestModuleForTestingResolvePathHasMany extends \Illuminate\Database\Eloquent\Model
{
}

class NamedFormElementTestModuleForTestingSkippedValues extends \Illuminate\Database\Eloquent\Model
{
}


1			<?php
2
3			use Mockery as m;
4			use SleepingOwl\Admin\Form\Element\NamedFormElement;
5
6			class NamedFormElementTest extends TestCase
7			{
8			public function tearDown()
9			{
10			m::close();
11			}
12
13			/**
14			* @param string $path
15			* @param string\|null $label
16			*
17			* @return NamedFormElement
18			*/
19			protected function getElement($path = 'path', $label = null)
20			{
21			return $this->getMockForAbstractClass(NamedFormElement::class, [
22			$path,
23			$label,
24			]);
25			}
26
27			/**
28			* @covers NamedFormElement::__constructor
29			* @covers NamedFormElement::getLabel
30			* @covers NamedFormElement::setLabel
31			* @covers NamedFormElement::getPath
32			* @covers NamedFormElement::setPath
33			* @covers NamedFormElement::getName
34			* @covers NamedFormElement::setName
35			*/
36			public function test_constructor()
37			{
38			$element = $this->getElement($path = 'path.test.test1.tets2', $label = 'Label');
39
40			$this->assertEquals($label, $element->getLabel());
41			$this->assertEquals($path, $element->getPath());
42			$this->assertEquals('path[test][test1][tets2]', $element->getName());
43			}
44
45			/**
46			* @covers NamedFormElement::__constructor
47			* @expectedException \SleepingOwl\Admin\Exceptions\Form\FormElementException
48			*/
49			public function test_constructor_exception()
50			{
51			$this->getElement(null);
52			}
53
54			/**
55			* @covers NamedFormElement::setAttribute
56			* @covers NamedFormElement::getAttribute
57			*/
58			public function test_gets_and_sets_attribute()
59			{
60			$element = $this->getElement();
61
62			$element->setModelAttributeKey('test');
63			$this->assertEquals('test', $element->getModelAttributeKey());
64			}
65
66			/**
67			* @covers NamedFormElement::setDefaultValue
68			* @covers NamedFormElement::getDefaultValue
69			*/
70			public function test_gets_and_sets_default_value()
71			{
72			$element = $this->getElement();
73
74			$element->setDefaultValue('test');
75			$this->assertEquals('test', $element->getDefaultValue());
76			}
77
78			/**
79			* @covers NamedFormElement::setHelpText
80			* @covers NamedFormElement::getHelpText
81			*/
82			public function test_gets_and_sets_help_text()
83			{
84			$element = $this->getElement();
85
86			$element->setHelpText('test');
87			$this->assertEquals('test', $element->getHelpText());
88
89			$helpText = m::mock(\Illuminate\Contracts\Support\Htmlable::class);
90			$helpText->shouldReceive('toHtml')->once()->andReturn('html');
91
92			$element->setHelpText($helpText);
93			$this->assertEquals('html', $element->getHelpText());
94			}
95
96			/**
97			* @covers NamedFormElement::required
98			* @covers NamedFormElement::getValidationRules
99			*/
100			public function test_add_required_rule()
101			{
102			$element = $this->getElement('key');
103
104			$element->required();
105			$this->assertEquals(['key' => ['required']], $element->getValidationRules());
106			}
107
108			/**
109			* @covers NamedFormElement::required
110			* @covers NamedFormElement::getValidationMessages
111			*/
112			public function test_add_required_rule_with_message()
113			{
114			$element = $this->getElement('key');
115
116			$element->required('required field');
117
118			$this->assertEquals(['key.required' => 'required field'], $element->getValidationMessages());
119			}
120
121			/**
122			* @covers NamedFormElement::required
123			* @covers NamedFormElement::getValidationRules
124			*/
125			public function test_add_unique_rule()
126			{
127			$element = $this->getElement('key');
128
129			$model = m::mock(\Illuminate\Database\Eloquent\Model::class);
130			$element->setModel($model);
131
132			$model->shouldReceive('getTable')->once()->andReturn('test_table');
133
134			$element->unique();
135			$this->assertEquals(['key' => ['unique:test_table,key']], $element->getValidationRules());
136			}
137
138			/**
139			* @covers NamedFormElement::unique
140			* @covers NamedFormElement::getValidationMessages
141			*/
142			public function test_add_unique_rule_with_message()
143			{
144			$element = $this->getElement('key');
145
146			$element->unique('must be unique');
147			$this->assertEquals(['key.unique' => 'must be unique'], $element->getValidationMessages());
148			}
149
150			/**
151			* @covers NamedFormElement::addValidationMessage
152			* @covers NamedFormElement::getValidationMessages
153			*/
154			public function test_gets_validation_messages()
155			{
156			$element = $this->getElement('key');
157
158			$element->addValidationMessage('test', 'test message');
159			$element->addValidationMessage('hello', 'hello message');
160			$this->assertEquals(['key.test' => 'test message', 'key.hello' => 'hello message'], $element->getValidationMessages());
161			}
162
163			/**
164			* @covers NamedFormElement::getValidationLabels
165			*/
166			public function test_gets_validation_labels()
167			{
168			$element = $this->getElement('key.subkey', 'Label');
169
170			$this->assertEquals(['key.subkey' => 'Label'], $element->getValidationLabels());
171			}
172
173			/**
174			* @covers NamedFormElement::getValueFromRequest
175			*/
176			public function test_gets_session_value_from_request()
177			{
178			$request = $this->app['request'];
179			$session = $request->getSession();
180
181			$element = $this->getElement('key.subkey', 'Label');
182			$session->shouldReceive('getOldInput')->andReturn('test');
183
184			$this->assertEquals('test', $element->getValueFromRequest($request));
185			}
186
187			/**
188			* @covers NamedFormElement::getValueFromRequest
189			*/
190			public function test_gets_value_from_request()
191			{
192			/** @var \Illuminate\Http\Request $request */
193			$request = $this->app['request'];
194			$request->offsetSet('key', [
195			'subkey1' => 'hello world',
196			]);
197
198			$session = $request->getSession();
199
200			$element = $this->getElement('key.subkey1', 'Label');
201			$session->shouldReceive('getOldInput')->andReturn(null);
202			$this->assertEquals('hello world', $element->getValueFromRequest($request));
203			}
204
205			/**
206			* @covers NamedFormElement::getValue
207			*/
208			public function test_gets_value_with_request()
209			{
210			$request = $this->app['request'];
211
212			$session = $request->getSession();
213			$session->shouldReceive('getOldInput')->andReturn(null);
214
215			$element = $this->getElement('key.subkey', 'Label');
216			$request->offsetSet('key', [
217			'subkey' => 'hello world',
218			]);
219
220			$this->assertEquals('hello world', $element->getValueFromModel());
221			}
222
223			/**
224			* @covers NamedFormElement::getValue
225			*/
226			public function test_gets_value()
227			{
228			$request = $this->app['request'];
229			$session = $request->getSession();
230			$session->shouldReceive('getOldInput')->andReturn(null);
231
232			$element = $this->getElement('key', 'Label');
233
234			$this->assertNull($element->getValueFromModel());
235
236			$element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
237			$model->shouldReceive('getAttribute')->with('key')->andReturn('value');
238
239			$this->assertNull($element->getValue());
240
241			$model->exists = true;
242			$this->assertEquals('value', $element->getValueFromModel());
243			}
244
245			/**
246			* @covers NamedFormElement::resolvePath
247			*/
248			public function test_resolving_path()
249			{
250			$element = $this->getElement('key', 'Label');
251			$element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
252
253			$this->assertEquals($model, $element->resolvePath());
254
255			// -------------
256
257			$element = $this->getElement('key.subkey', 'Label');
258			$element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
259			$model->exists = true;
260
261			$model->shouldReceive('getAttribute')->andReturn($subModel = m::mock(\Illuminate\Database\Eloquent\Model::class));
262
263			$this->assertEquals($subModel, $element->resolvePath());
264
265			// -------------
266
267			$element = $this->getElement('key.subkey', 'Label');
268			$element->setModel($model = new NamedFormElementTestModuleForTestingResolvePath());
269
270			$this->assertInstanceOf(NamedFormElementTestModuleForTestingResolvePathBelongsTo::class, $element->resolvePath());
271
272			// -------------
273
274			$element = $this->getElement('key1.subkey', 'Label');
275			$element->setModel($model = new NamedFormElementTestModuleForTestingResolvePath());
276
277			$this->assertInstanceOf(NamedFormElementTestModuleForTestingResolvePathHasOne::class, $element->resolvePath());
278
279			// -------------
280
281			$element = $this->getElement('key2.subkey', 'Label');
282			$element->setModel($model = new NamedFormElementTestModuleForTestingResolvePath());
283
284			$this->assertInstanceOf(NamedFormElementTestModuleForTestingResolvePathHasMany::class, $element->resolvePath());
285			}
286
287			/**
288			* @covers NamedFormElement::toArray
289			*/
290			public function test_gets_array()
291			{
292			$element = $this->getElement('key2.subkey', 'Label');
293
294			$request = $this->app['request'];
295			$session = $request->getSession();
296			$session->shouldReceive('getOldInput')->andReturn(null);
297
298			$this->assertEquals([
299			'value' => null,
300			'readonly' => false,
301			'model' => null,
302			'id' => 'key2[subkey]',
303			'name' => 'key2[subkey]',
304			'path' => 'key2.subkey',
305			'label' => 'Label',
306			'helpText' => null,
307			'required' => false,
308			], $element->toArray());
309			}
310
311			public function test_save()
312			{
313			$request = $this->app['request'];
314
315			$session = $request->getSession();
316			$session->shouldReceive('getOldInput')->andReturn(null);
317
318			$request->offsetSet($key = 'key', $value = 'hello world');
319			$element = $this->getElement($key, 'Label');
320
321			$element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
322			$model->shouldReceive('setAttribute')->with('key', $value);
323
324			$element->save($request);
325			}
326
327			public function test_sets_model_attribute()
328			{
329			$element = $this->getElement('key', 'Label');
330			$value = 'value';
331
332			$element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
333			$model->shouldReceive('setAttribute')->with('key', $value);
334
335			$element->setModelAttribute($value);
336			}
337
338			/**
339			* @covers FormElement::isValueSkipped()
340			* @covers FormElement::setValueSkipped()
341			*/
342			public function test_does_not_set_skipped_values()
343			{
344			$nameElement = $this->getElement('name', 'Name');
345			$passwordElement = $this->getElement('password', 'Password')->setValueSkipped(true);
346
347			$model = new NamedFormElementTestModuleForTestingSkippedValues();
348			foreach ([$nameElement, $passwordElement] as $element) {
349			/* @var $element NamedFormElement */
350			$element->setModel($model);
351			$element->setModelAttribute($element->getLabel());
352			}
353
354			$attributes = array_keys($model->getAttributes());
355			$this->assertFalse(in_array('password', $attributes, true));
356			$this->assertCount(1, $attributes);
357			}
358
359			public function test_prepare_value()
360			{
361			$element = $this->getElement('key', 'Label');
362			$value = 'value';
363
364			$this->assertEquals($value, $element->prepareValue($value));
365
366			$element->mutateValue(function ($value) {
367			return strtoupper($value);
368			});
369
370			$this->assertEquals('VALUE', $element->prepareValue($value));
371			}
372
373			public function test_mutator()
374			{
375			$element = $this->getElement('key', 'Label');
376			$this->assertFalse($element->hasMutator());
377
378			$element->mutateValue(function ($value) {
379			return strtoupper($value);
380			});
381			$this->assertTrue($element->hasMutator());
382			}
383
384			public function test_get_model_by_path()
385			{
386			$element = $this->getElement('key', 'Label');
387
388			$element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
389
390			$this->assertEquals($model, $this->callMethodByPath($element, 'key'));
391
392			$element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
393			$model->shouldReceive('getAttribute')->with('key')->andReturn('test');
394
395			$this->assertNull($this->callMethodByPath($element, 'key.key1'));
396
397			$element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
398			$model->shouldReceive('getAttribute')->with('key')->andReturn(
399			$model1 = m::mock(\Illuminate\Database\Eloquent\Model::class)
400			);
401
402			$this->assertEquals($model1, $this->callMethodByPath($element, 'key.key1'));
403			}
404
405			/**
406			* @expectedException LogicException
407			*/
408			public function test_get_model_by_path_exception()
409			{
410			$element = $this->getElement('key', 'Label');
411
412			$element->setModel($model = m::mock(\Illuminate\Database\Eloquent\Model::class));
413			$model->shouldReceive('getAttribute')->with('key')->andReturn(
414			$model1 = m::mock(\Illuminate\Database\Eloquent\Model::class)
415			);
416
417			$model1->shouldReceive('getAttribute')->with('key1');
418
419			$this->callMethodByPath($element, 'key.key1.title');
420			}
421
422			/**
423			* @param NamedFormElement $element
424			* @param $path
425			*
426			* @return mixed
427			*/
428			protected function callMethodByPath(NamedFormElement $element, $path)
429			{
430			$reflection = new ReflectionClass($element);
431
432			$method = $reflection->getMethod('getModelByPath');
433			$method->setAccessible(true);
434
435			return $method->invoke($element, $path);
436			}
437			}
438
439			class NamedFormElementTestModuleForTestingResolvePath extends \Illuminate\Database\Eloquent\Model
440			{
441			public function key()
442			{
443			return $this->hasOne(NamedFormElementTestModuleForTestingResolvePathBelongsTo::class);
444			}
445
446			public function key1()
447			{
448			return $this->hasOne(NamedFormElementTestModuleForTestingResolvePathHasOne::class);
449			}
450
451			public function key2()
452			{
453			return $this->hasMany(NamedFormElementTestModuleForTestingResolvePathHasMany::class);
454			}
455			}
456
457			class NamedFormElementTestModuleForTestingResolvePathBelongsTo extends \Illuminate\Database\Eloquent\Model
458			{
459			}
460
461			class NamedFormElementTestModuleForTestingResolvePathHasOne extends \Illuminate\Database\Eloquent\Model
462			{
463			}
464
465			class NamedFormElementTestModuleForTestingResolvePathHasMany extends \Illuminate\Database\Eloquent\Model
466			{
467			}
468
469			class NamedFormElementTestModuleForTestingSkippedValues extends \Illuminate\Database\Eloquent\Model
470			{
471			}
472

LaravelRUS / SleepingOwlAdmin

GitHub Access Token became invalid

Push — master ( b864c9...ed9166 )

NamedFormElementTestModuleForTestingResolvePath A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

Duplication Side-by-Side

Filter issues like