HelpersTest::testArrayIsSubsetOfHelper() - Code Metrics - deviouspk/larapi - Measure and Improve Code Quality continuously with Scrutinizer

HelpersTest::testArrayIsSubsetOfHelper() A
last analyzed 2019-04-15 14:07 UTC

↳ Parent: HelpersTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	56
Code Lines	35

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	35
nc	1
nop	0
dl	0
loc	56
rs	9.36
c	0
b	0
f	0

How to fix Long Method

<?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 Foundation\Traits\DisableRefreshDatabase;
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
{
    use DisableRefreshDatabase;

    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));
    }

    public function testSplitCapitalStringToUnderscores(){
        $this->assertEquals("proxy_uptime_collection", split_caps_to_underscore("ProxyUptimeCollection"));
    }
}


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

deviouspk / larapi

HelpersTest::testArrayIsSubsetOfHelper() A last analyzed 2019-04-15 14:07 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

HelpersTest::testArrayIsSubsetOfHelper() A
last analyzed 2019-04-15 14:07 UTC