Foundation\Tests\HelpersTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	testUnauthenticatedUserHelper()	0	4	1
A	testClassUsesTraitHelper()	0	4	1
A	testAuthenticatedUserHelper()	0	4	1
A	testIsAssocativeArrayHelper()	0	20	1
A	testArrayIsSubsetOfHelper()	0	58	1
A	testRandomArrayElementHelper()	0	13	1
A	testClassShortNameHelper()	0	3	1
A	testClassImplementsHelper()	0	6	1
A	testArrayKeysExistHelper()	0	21	1

<?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 Illuminate\Contracts\Auth\Authenticatable;
use Illuminate\Contracts\Filesystem\Filesystem;
use Illuminate\Foundation\Auth\Access\Authorizable;
use Modules\User\Entities\User;
use PHPUnit\Framework\Constraint\ArraySubset;
use Symfony\Component\HttpKernel\Exception\UnauthorizedHttpException;

class HelpersTest extends TestCase
{
    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 testUnauthenticatedUserHelper()
    {
        $this->expectException(UnauthorizedHttpException::class);
        get_authenticated_user();
    }

    public function testAuthenticatedUserHelper()
    {
        $this->actingAs(factory(User::class)->make());

It seems like factory(Modules\User\Entities\User::class)->make() can also be of type Illuminate\Database\Eloquent\Model; however, parameter $user of Illuminate\Foundation\Testing\TestCase::actingAs() does only seem to accept Illuminate\Contracts\Auth\Authenticatable, maybe add an additional type check?

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