HelpersTest::testUnauthenticatedUserHelper() - Code Metrics - Inspection of "fixing scrutinizer build 5" - deviouspk/larapi - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 139939...b4b8e8 )

by Arthur

created 2019-03-10 16:46 UTC

HelpersTest::testUnauthenticatedUserHelper() A

↳ Parent: HelpersTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	4
rs	10
c	0
b	0
f	0

<?php
/**
 * Created by PhpStorm.
 * User: arthur
 * Date: 03.10.18
 * Time: 22:58.
 */

namespace Foundation\Tests;

use Foundation\Abstracts\Tests\CreatesApplication;
use Foundation\Abstracts\Tests\TestCase;
use Foundation\Core\Larapi;
use Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Contracts\Filesystem\Filesystem;
use Illuminate\Foundation\Auth\Access\Authorizable;
use Modules\User\Entities\User;

class HelpersTest extends TestCase
{
    const TEST_CONSTANT = 'test';

    private $randomTestVariable = 'blablabla';

    public function testClassImplementsHelper()
    {
        $this->assertFalse(class_implements_interface(self::class, Filesystem::class));
        $this->assertTrue(class_implements_interface(self::class, \PHPUnit\Framework\Test::class));
        $this->assertFalse(class_implements_interface(new self(), Filesystem::class));
        $this->assertTrue(class_implements_interface(new self(), \PHPUnit\Framework\Test::class));
    }

    public function testAuthenticatedUserHelper()
    {
        $this->actingAs(factory(User::class)->make());
        $this->assertTrue(class_implements_interface(get_authenticated_user(), Authenticatable::class));
    }

    public function testClassShortNameHelper()
    {
        $this->assertEquals('HelpersTest', get_short_class_name(self::class));
    }

    public function testRandomArrayElementHelper()
    {
        $array = [
            'test',
            'x',
            'blabla',
            'hello',
            'hey',
        ];

        $randomArrayElement = get_random_array_element($array);

        $this->assertContains($randomArrayElement, $array);
    }

    public function testClassUsesTraitHelper()
    {
        $this->assertTrue(class_uses_trait(self::class, CreatesApplication::class));
        $this->assertFalse(class_uses_trait(self::class, Authorizable::class));
    }

    public function testArrayKeysExistHelper()
    {
        $requiredKeys = [
            'input1',
            'input3',
            'input4',
        ];

        $invalidArray = [
            'input1' => 5,
            'input3' => 4,
            'input5' => 3,
        ];

        $validArray = [
            'input1' => 5,
            'input3' => 4,
            'input4' => 3,
        ];
        $this->assertTrue(array_keys_exists($requiredKeys, $validArray));
        $this->assertFalse(array_keys_exists($requiredKeys, $invalidArray));
    }

    public function testArrayIsSubsetOfHelper()
    {
        $keyValueArray = [
            'input1' => 5,
            'input3' => 4,
            'input4' => 3,
        ];

        $valueArray = [
            'value1',
            'value2',
            'value4',
        ];

        $keyValueSubset = [
            'input1' => 5,
            'input3' => 4,
        ];

        $keyValueInvalidSubset = [
            'input1' => 4,
            'input3' => 4,
        ];

        $keyValueInvalidSubset2 = [
            'input2' => 5,
        ];

        $valueSubset = [
            'value2',
            'value4',
        ];

        $valueSubset2 = [
            'value1',
        ];

        $invalidValueSubset = [
            'value5',
        ];

        $invalidValueSubset2 = [
            'value1',
            'value2',
            'value3',
            'value4',
        ];

        $this->assertTrue(array_is_subset_of($keyValueSubset, $keyValueArray));
        $this->assertFalse(array_is_subset_of($keyValueInvalidSubset, $keyValueArray));
        $this->assertFalse(array_is_subset_of($keyValueInvalidSubset2, $keyValueArray));

        $this->assertTrue(array_is_subset_of($valueSubset, $valueArray));
        $this->assertTrue(array_is_subset_of($valueSubset2, $valueArray));
        $this->assertFalse(array_is_subset_of($invalidValueSubset, $valueArray));
        $this->assertFalse(array_is_subset_of($invalidValueSubset2, $valueArray));
    }

    public function testIsAssocativeArrayHelper()
    {
        $associativeArray = [
            'key1' => 'value1',
            'key3' => 'value3',
        ];

        $array = [
            0, 1, 2, 3,
        ];

        $mixedArray = [
            'key1' => 'value1',
            'randomvalue',
            'key3' => 'value3',
        ];

        $this->assertTrue(is_associative_array($associativeArray));
        $this->assertTrue(is_associative_array($mixedArray));
        $this->assertFalse(is_associative_array($array));
    }

    public function testGetClassPropertyHelper()
    {
        $this->assertEquals($this->randomTestVariable, get_class_property(static::class, 'randomTestVariable'));
    }

    public function testGetClassConstants()
    {
        $this->assertArrayHasKey('TEST_CONSTANT', get_class_constants(static::class));
        $this->assertEquals(self::TEST_CONSTANT, get_class_constants(static::class)['TEST_CONSTANT']);
    }

    public function testInstanceWithoutConstructor()
    {
        $this->assertInstanceOf(Larapi::class, instance_without_constructor(Larapi::class));
    }
}


1			<?php
2			/**
3			* Created by PhpStorm.
4			* User: arthur
5			* Date: 03.10.18
6			* Time: 22:58.
7			*/
8
9			namespace Foundation\Tests;
10
11			use Foundation\Abstracts\Tests\CreatesApplication;
12			use Foundation\Abstracts\Tests\TestCase;
13			use Foundation\Core\Larapi;
14			use Illuminate\Contracts\Auth\Authenticatable;
15			use Illuminate\Contracts\Filesystem\Filesystem;
16			use Illuminate\Foundation\Auth\Access\Authorizable;
17			use Modules\User\Entities\User;
18
19			class HelpersTest extends TestCase
20			{
21			const TEST_CONSTANT = 'test';
22
23			private $randomTestVariable = 'blablabla';
24
25			public function testClassImplementsHelper()
26			{
27			$this->assertFalse(class_implements_interface(self::class, Filesystem::class));
28			$this->assertTrue(class_implements_interface(self::class, \PHPUnit\Framework\Test::class));
29			$this->assertFalse(class_implements_interface(new self(), Filesystem::class));
30			$this->assertTrue(class_implements_interface(new self(), \PHPUnit\Framework\Test::class));
31			}
32
33			public function testAuthenticatedUserHelper()
34			{
35			$this->actingAs(factory(User::class)->make());
36			$this->assertTrue(class_implements_interface(get_authenticated_user(), Authenticatable::class));
37			}
38
39			public function testClassShortNameHelper()
40			{
41			$this->assertEquals('HelpersTest', get_short_class_name(self::class));
42			}
43
44			public function testRandomArrayElementHelper()
45			{
46			$array = [
47			'test',
48			'x',
49			'blabla',
50			'hello',
51			'hey',
52			];
53
54			$randomArrayElement = get_random_array_element($array);
55
56			$this->assertContains($randomArrayElement, $array);
57			}
58
59			public function testClassUsesTraitHelper()
60			{
61			$this->assertTrue(class_uses_trait(self::class, CreatesApplication::class));
62			$this->assertFalse(class_uses_trait(self::class, Authorizable::class));
63			}
64
65			public function testArrayKeysExistHelper()
66			{
67			$requiredKeys = [
68			'input1',
69			'input3',
70			'input4',
71			];
72
73			$invalidArray = [
74			'input1' => 5,
75			'input3' => 4,
76			'input5' => 3,
77			];
78
79			$validArray = [
80			'input1' => 5,
81			'input3' => 4,
82			'input4' => 3,
83			];
84			$this->assertTrue(array_keys_exists($requiredKeys, $validArray));
85			$this->assertFalse(array_keys_exists($requiredKeys, $invalidArray));
86			}
87
88			public function testArrayIsSubsetOfHelper()
89			{
90			$keyValueArray = [
91			'input1' => 5,
92			'input3' => 4,
93			'input4' => 3,
94			];
95
96			$valueArray = [
97			'value1',
98			'value2',
99			'value4',
100			];
101
102			$keyValueSubset = [
103			'input1' => 5,
104			'input3' => 4,
105			];
106
107			$keyValueInvalidSubset = [
108			'input1' => 4,
109			'input3' => 4,
110			];
111
112			$keyValueInvalidSubset2 = [
113			'input2' => 5,
114			];
115
116			$valueSubset = [
117			'value2',
118			'value4',
119			];
120
121			$valueSubset2 = [
122			'value1',
123			];
124
125			$invalidValueSubset = [
126			'value5',
127			];
128
129			$invalidValueSubset2 = [
130			'value1',
131			'value2',
132			'value3',
133			'value4',
134			];
135
136			$this->assertTrue(array_is_subset_of($keyValueSubset, $keyValueArray));
137			$this->assertFalse(array_is_subset_of($keyValueInvalidSubset, $keyValueArray));
138			$this->assertFalse(array_is_subset_of($keyValueInvalidSubset2, $keyValueArray));
139
140			$this->assertTrue(array_is_subset_of($valueSubset, $valueArray));
141			$this->assertTrue(array_is_subset_of($valueSubset2, $valueArray));
142			$this->assertFalse(array_is_subset_of($invalidValueSubset, $valueArray));
143			$this->assertFalse(array_is_subset_of($invalidValueSubset2, $valueArray));
144			}
145
146			public function testIsAssocativeArrayHelper()
147			{
148			$associativeArray = [
149			'key1' => 'value1',
150			'key3' => 'value3',
151			];
152
153			$array = [
154			0, 1, 2, 3,
155			];
156
157			$mixedArray = [
158			'key1' => 'value1',
159			'randomvalue',
160			'key3' => 'value3',
161			];
162
163			$this->assertTrue(is_associative_array($associativeArray));
164			$this->assertTrue(is_associative_array($mixedArray));
165			$this->assertFalse(is_associative_array($array));
166			}
167
168			public function testGetClassPropertyHelper()
169			{
170			$this->assertEquals($this->randomTestVariable, get_class_property(static::class, 'randomTestVariable'));
171			}
172
173			public function testGetClassConstants()
174			{
175			$this->assertArrayHasKey('TEST_CONSTANT', get_class_constants(static::class));
176			$this->assertEquals(self::TEST_CONSTANT, get_class_constants(static::class)['TEST_CONSTANT']);
177			}
178
179			public function testInstanceWithoutConstructor()
180			{
181			$this->assertInstanceOf(Larapi::class, instance_without_constructor(Larapi::class));
182			}
183			}
184

deviouspk / larapi

Push — master ( 139939...b4b8e8 )

HelpersTest::testUnauthenticatedUserHelper() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like