App\Ship\Features\Tests\PhpUnit\TestsAuthHelperTrait

Complexity

Total Complexity

23

Size/Duplication

Total Lines	198
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getTestingUser()	0	5	2
A	getTestingUserWithoutAccess()	0	4	1
A	findOrCreateTestingUser()	0	4	2
A	createTestingUser()	0	14	1
A	factoryCreateUser()	0	4	1
A	prepareUserDetails()	0	11	2
A	prepareUserPassword()	0	10	2
A	getAccess()	0	4	2
A	setupTestingUserAccess()	0	9	2
A	setupTestingUserRoles()	0	10	4
A	setupTestingUserPermissions()	0	8	3
A	getNullAccess()	0	7	1

<?php

namespace App\Ship\Features\Tests\PhpUnit;

use App;
use App\Containers\Authentication\Tasks\ApiLoginThisUserObjectTask;
use App\Containers\User\Models\User;
use Artisan;
use Dingo\Api\Http\Response as DingoAPIResponse;
use Illuminate\Support\Facades\Hash;

/**
 * Class TestsAuthHelperTrait.
 *
 * Tests helper for authentication and authorization.
 *
 * @author  Mahmoud Zalt <mahmoud@zalt.me>
 */
trait TestsAuthHelperTrait
{

    /**
     * Logged in user object.
     *
     * @var User
     */
    protected $testingUser;

    /**
     * Roles and permissions, to be attached on the user
     *
     * @var array
     */
    protected $access = [
        'permissions' => '',
        'roles'       => '',
    ];

    /**
     * Try to get the last logged in User, if not found then create new one.
     * Note: if $userDetails are provided it will always create new user, even
     * if another one was previously created during the execution of your test.
     *
     * By default Users will be given the Roles and Permissions found int he class
     * `$access` property. But the $access parameter can be used to override the
     * defined roles and permissions in the `$access` property of your class.
     *
     * @param null $access      roles and permissions you'd like to provide this user with
     * @param null $userDetails what to be attached on the User object
     *
     * @return  \App\Containers\User\Models\User
     */
    public function getTestingUser($userDetails = null, $access = null)
    {
        return is_null($userDetails) ? $this->findOrCreateTestingUser($userDetails, $access)
            : $this->createTestingUser($userDetails, $access);
    }

    /**
     * Same as `getTestingUser()` but always overrides the User Access
     * (roles and permissions) with null. So the user can be used to test
     * if unauthorized user tried to access your protected endpoint.
     *
     * @param null $userDetails
     *
     * @return  \App\Containers\User\Models\User
     */
    public function getTestingUserWithoutAccess($userDetails = null)
    {
        return $this->getTestingUser($userDetails, $this->getNullAccess());
    }

    /**
     * @param $userDetails
     * @param $access
     *
     * @return  \App\Containers\User\Models\User
     */
    private function findOrCreateTestingUser($userDetails, $access)
    {
        return $this->testingUser ? : $this->createTestingUser($userDetails, $access);
    }

    /**
     * @param null $access
     * @param null $userDetails
     *
     * @return  User
     */
    private function createTestingUser($userDetails = null, $access = null)
    {
        // create new user
        $user = $this->factoryCreateUser($userDetails);

        // assign user roles and permissions based on the access property
        $user = $this->setupTestingUserAccess($user, $access);

        // log the user in
        $user = App::make(ApiLoginThisUserObjectTask::class)->run($user);

        // set the created user
        return $this->testingUser = $user;
    }

    /**
     * @param null $userDetails
     *
     * @return  User
     */
    private function factoryCreateUser($userDetails = null)
    {
        return factory(User::class)->create($this->prepareUserDetails($userDetails));
    }

    /**
     * @param null $userDetails
     *
     * @return  array
     */
    private function prepareUserDetails($userDetails = null)
    {
        $defaultUserDetails = [
            'name'     => $this->faker->name,

The property faker does not exist. Did you maybe forget to declare it?

            'email'    => $this->faker->email,
            'password' => 'testing-password',
        ];

        // if no user detail provided, use the default details, to find the password or generate one before encoding it
        return $this->prepareUserPassword($userDetails ? : $defaultUserDetails);;
    }

    /**
     * @param $userDetails
     *
     * @return  null
     */
    private function prepareUserPassword($userDetails)
    {
        // get password from the user details or generate one
        $password = isset($userDetails['password']) ? $userDetails['password'] : $this->faker->password;

        // hash the password and set it back at the user details
        $userDetails['password'] = Hash::make($password);

        return $userDetails;
    }

    /**
     * @return  array|null
     */
    private function getAccess()
    {
        return isset($this->access) ? $this->access : null;
    }

    /**
     * @param $user
     * @param $access
     *
     * @return  mixed
     */
    private function setupTestingUserAccess($user, $access)
    {
        $access = $access ? : $this->getAccess();

        $user = $this->setupTestingUserPermissions($user, $access);
        $user = $this->setupTestingUserRoles($user, $access);

        return $user;
    }

    /**
     * @param $user
     * @param $access
     *
     * @return  mixed
     */
    private function setupTestingUserRoles($user, $access)
    {
        if (isset($access['roles']) && !empty($access['roles'])) {
            if (!$user->hasRole($access['roles'])) {
                $user->assignRole($access['roles']);
            }
        }

        return $user;
    }

    /**
     * @param $user
     * @param $access
     *
     * @return  mixed
     */
    private function setupTestingUserPermissions($user, $access)
    {
        if (isset($access['permissions']) && !empty($access['permissions'])) {
            $user->givePermissionTo($access['permissions']);
        }

        return $user;
    }


    /**
     * @return  array
     */
    private function getNullAccess()
    {
        return [
            'permissions' => null,
            'roles'       => null
        ];
    }

}