Yawik\Behat\UserContext

Complexity

Total Complexity

48

Size/Duplication

Total Lines	432
Duplicated Lines	1.16 %

Coupling/Cohesion

Components	1
Dependencies	21

Importance

Changes	3
Bugs	2	Features	0

27 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	15	2
A	tearDown()	0	22	2
A	beforeScenario()	0	7	1
A	iSignInWithSocialUser()	0	8	2
A	iAmLoggedInAsARecruiter()	0	13	2
A	iHaveLoggedOut()	0	5	1
A	iDonTHaveUser()	0	8	2
A	iHaveUserWithTheFollowing()	0	23	2
A	iAmLoggedInAsAnAdmin()	0	5	1
A	startLogin()	0	11	3
A	getUserRepository()	0	4	1
A	thereIsAUserIdentifiedBy()	0	14	3
B	createUser()	0	34	2
A	iHaveMainOrganization()	5	21	3
A	getMainOrganization()	0	4	1
A	iWantToLogIn()	0	6	1
A	iSpecifyTheUsernameAs()	0	4	1
A	iSpecifyThePasswordAs()	0	4	1
A	iAmLoggedInAsIdentifiedBy()	0	14	2
A	iLogIn()	0	4	1
A	iPressLogoutLink()	0	5	1
A	iLogInWith()	0	10	1
A	iGoToProfilePage()	0	5	1
B	thereIsAUserWithTheFollowing()	0	15	6
A	addCreatedUser()	0	6	2
A	iWantToChangeMyPassword()	0	5	1
A	getCurrentUser()	0	7	2

<?php
/**
 * YAWIK
 *
 * @filesource
 * @license MIT
 * @copyright  2013 - 2017 Cross Solution <http://cross-solution.de>
 */

namespace Yawik\Behat;

use Auth\Entity\User as User;
use Auth\Entity\UserInterface;
use Auth\Repository\User as UserRepository;
use Auth\Service\Register;
use Behat\Behat\Context\Context;
use Behat\Behat\Hook\Scope\BeforeScenarioScope;
use Behat\Gherkin\Node\TableNode;
use Behat\MinkExtension\Context\MinkContext;
use Core\Entity\Permissions;
use Doctrine\Common\Util\Inflector;
use Doctrine\ODM\MongoDB\DocumentManager;
use Doctrine\ODM\MongoDB\Event\LifecycleEventArgs;
use Doctrine\ODM\MongoDB\Events;
use Organizations\Entity\Organization;
use Organizations\Entity\OrganizationName;
use Organizations\Repository\Organization as OrganizationRepository;
use Yawik\Behat\Exception\FailedExpectationException;

class UserContext implements Context
{
    use CommonContextTrait;
	
	/**
	 * @var User[]
	 */
	static private $users = [];
	
	/**
	 * @var UserRepository
	 */
	static private $userRepo;
	
	private $socialLoginInfo = [];

    /**
     * @var DocumentManager
     */
	static private $dm;
	
	/**
	 * @var UserInterface
	 */
	private $loggedInUser;

    /**
     * @var Organization
     */
	private $mainOrganization;

    /**
     * @var User
     */
    protected $currentUser;
	
	public function __construct($parameters=[])
	{
		$defaultLoginInfo = [
			'facebook' => [
				'email' => getenv('FACEBOOK_USER_EMAIL'),
				'pass' => getenv('FACEBOOK_USER_PASSWORD')
			],
			'linkedin' => [
				'session_key-login' => getenv('LINKEDIN_USER_EMAIL'),
				'session_password-login' => getenv('LINKEDIN_USER_PASSWORD')
			],
		];
		$socialLoginConfig = isset($parameters['social_login_info']) ? $parameters['social_login_info']:[];
		$this->socialLoginInfo = array_merge($defaultLoginInfo,$socialLoginConfig);
	}

    /**
     * Empty all data every each tests
     *
     * @AfterSuite
     */
	static public function tearDown()

As per PSR2, the static declaration should come after the visibility declaration.

    {
        $dm = static::$dm;

Since $dm is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $dm to at least protected.

        $documents = [
            'Applications\Entity\Application',
            'Cv\Entity\Cv',
            'Jobs\Entity\Job',
            'Organizations\Entity\Organization',
            'Auth\Entity\User',
            'Jobs\Entity\Category',
            'Auth\Entity\UserImage',
            'Organizations\Entity\OrganizationName',
        ];
        foreach($documents as $document){
            $dm->createQueryBuilder($document)
                ->remove()
                ->getQuery()
                ->execute()
            ;
        }
    }

	/**
	 * @BeforeScenario
	 * @param BeforeScenarioScope $scope
	 */
	public function beforeScenario(BeforeScenarioScope $scope)
	{
		$this->minkContext = $scope->getEnvironment()->getContext(MinkContext::class);

It seems like you code against a concrete implementation and not the interface Behat\Testwork\Environment\Environment as the method getContext() does only exist in the following implementations of said interface: Behat\Behat\Context\Environment\InitializedContextEnvironment, FriendsOfBehat\ContextServiceExtension\Context\Environment\InitialisedContextServiceEnvironment.

		$this->coreContext = $scope->getEnvironment()->getContext(CoreContext::class);

It seems like you code against a concrete implementation and not the interface Behat\Testwork\Environment\Environment as the method getContext() does only exist in the following implementations of said interface: Behat\Behat\Context\Environment\InitializedContextEnvironment, FriendsOfBehat\ContextServiceExtension\Context\Environment\InitialisedContextServiceEnvironment.

		static::$userRepo = $this->getUserRepository();

Since $userRepo is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $userRepo to at least protected.

		static::$dm = $this->getUserRepository()->getDocumentManager();

Since $dm is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $dm to at least protected.

	}
	
	/**
	 * @When I fill in login form with :provider user
	 */
	public function iSignInWithSocialUser($provider)
	{
		$provider = strtolower($provider);
		$mink = $this->minkContext;
		foreach($this->socialLoginInfo[$provider] as $field=>$value){
			$mink->fillField($field,$value);
		}
	}
	
	/**
	 * @Given I am logged in as a recruiter
	 * @Given I am logged in as a recruiter with :organization as organization
	 */
	public function iAmLoggedInAsARecruiter($organization=null)
	{
		$user = $this->thereIsAUserIdentifiedBy(
			'test@recruiter.com',
			'test',User::ROLE_RECRUITER,
			'Test Recruiter',
			$organization
		);
		$this->startLogin($user,'test');

It seems like $user defined by $this->thereIsAUserIdentifiedBy('test@recruiter.com', 'test', \Auth\Entity\User::ROLE_RECRUITER, 'Test Recruiter', $organization) on line 140 can also be of type object<Core\Entity\EntityInterface>; however, Yawik\Behat\UserContext::startLogin() does only seem to accept object<Auth\Entity\UserInterface>, maybe add an additional type check?

		if(!is_null($organization)){
            $this->iHaveMainOrganization($user,$organization);

It seems like $user defined by $this->thereIsAUserIdentifiedBy('test@recruiter.com', 'test', \Auth\Entity\User::ROLE_RECRUITER, 'Test Recruiter', $organization) on line 140 can also be of type object<Core\Entity\EntityInterface>; however, Yawik\Behat\UserContext::iHaveMainOrganization() does only seem to accept object<Auth\Entity\UserInterface>, maybe add an additional type check?

        }
	}

    /**
     * @Given I am logged out
     */
    public function iHaveLoggedOut()
    {
        $url = $this->minkContext->locatePath('/logout');
        $this->minkContext->getSession()->visit($url);
    }

	
	/**
	 * @Given I don't have :login user
	 * @param string $login
	 */
	public function iDonTHaveUser($login)
	{
		$repo = $this->getUserRepository();
		$user=$repo->findByLogin($login);
		if($user instanceof UserInterface){
			$repo->remove($user,true);
		}
	}
	
	/**
	 * @Given I have a :role with the following:
     * @Given I have an :role with the following:
     *
	 * @param $role
	 * @param TableNode $fields
	 */
	public function iHaveUserWithTheFollowing($role,TableNode $fields)
	{
		$normalizedFields = [
			'login' => 'test@login.com',
			'fullName' => 'Test Login',
			'role' => $role,
			'password' => 'test',
			'organization' => 'Cross Solution'
		];
		foreach($fields->getRowsHash() as $field=>$value){
			$field = Inflector::camelize($field);
			$normalizedFields[$field] = $value;
		}
		
		$this->thereIsAUserIdentifiedBy(
			$normalizedFields['login'],
			$normalizedFields['password'],
			$role,
			$normalizedFields['fullName'],
			$normalizedFields['organization']
		);
		
	}
	
	/**
	 * @Given I am logged in as an administrator
	 */
	public function iAmLoggedInAsAnAdmin()
	{
		$user = $this->thereIsAUserIdentifiedBy('test@admin.com','test',User::ROLE_ADMIN);
		$this->startLogin($user,'test');

It seems like $user defined by $this->thereIsAUserIdentifiedBy('test@admin.com', 'test', \Auth\Entity\User::ROLE_ADMIN) on line 211 can also be of type object<Core\Entity\EntityInterface>; however, Yawik\Behat\UserContext::startLogin() does only seem to accept object<Auth\Entity\UserInterface>, maybe add an additional type check?

	}
	
	private function startLogin(UserInterface $user, $password)
	{
		$currentUser = $this->currentUser;
		if(!is_object($currentUser) || $user->getId()!=$currentUser->getId()){
			$this->iWantToLogIn();
			$this->iSpecifyTheUsernameAs($user->getLogin());
			$this->iSpecifyThePasswordAs($password);
			$this->iLogIn();
			$this->currentUser = $user;

$user is of type object<Auth\Entity\UserInterface>, but the property $currentUser was declared to be of type object<Auth\Entity\User>. Are you sure that you always receive this specific sub-class here, or does it make sense to add an instanceof check?

		}
	}
	
	/**
	 * @return UserRepository
	 */
	public function getUserRepository()
	{
		return $this->coreContext->getRepositories()->get('Auth\Entity\User');
	}
	
	/**
	 * @Given there is a user :email identified by :password
	 */
	public function thereIsAUserIdentifiedBy($email, $password,$role=User::ROLE_RECRUITER,$fullname="Test Recruiter",$organization=null)
	{
		$repo = $this->getUserRepository();
		if(!is_object($user=$repo->findByEmail($email))){
			$user = $this->createUser($email,$password,$role,$fullname,$organization);

The call to UserContext::createUser() has too many arguments starting with $organization.

		}
		
		if(!is_null($organization)){
			$this->iHaveMainOrganization($user,$organization);

It seems like $user can also be of type object<Core\Entity\EntityInterface>; however, Yawik\Behat\UserContext::iHaveMainOrganization() does only seem to accept object<Auth\Entity\UserInterface>, maybe add an additional type check?

		}
		$this->addCreatedUser($user);

It seems like $user can also be of type object<Core\Entity\EntityInterface>; however, Yawik\Behat\UserContext::addCreatedUser() does only seem to accept object<Auth\Entity\UserInterface>, maybe add an additional type check?

		$repo->getDocumentManager()->refresh($user);
		return $user;
	}
	
	/**
	 * @param $email
	 * @param $password
	 * @param $username
	 * @param string $fullname
	 * @param string $role
	 *
	 * @return \Auth\Entity\UserInterface

Should the return type not be \Core\Entity\EntityInterface?

	 */
	public function createUser($email,$password,$role=User::ROLE_RECRUITER,$fullname="Test Recruiter")
	{
		/* @var Register $service */
		/* @var User $user */
		$repo = $this->getUserRepository();
		$user = $repo->create([]);
		$user->setLogin($email);
		$user->setPassword($password);
		$user->setRole($role);
		$settings = $user->getSettings('Applications');

$settings is not used, you could remove the assignment.

		
		$expFullName = explode(' ',$fullname);
		$info = $user->getInfo();
		$info->setFirstName(array_shift($expFullName));
		$info->setLastName(count($expFullName)>0 ? implode(' ',$expFullName):'');
		$info->setEmail($email);
		$info->setEmailVerified(true);
		$repo->store($user);
		$repo->getDocumentManager()->refresh($user);
		
		$eventArgs = new LifecycleEventArgs($user, $repo->getDocumentManager());
		$repo->getDocumentManager()->getEventManager()->dispatchEvent(
			Events::postLoad,
			$eventArgs
		);
		/* @var \Core\EventManager\EventManager $events */
		/* @var \Auth\Listener\Events\AuthEvent $event */
		//@TODO: [Behat] event not working in travis
		//$events = $this->coreContext->getEventManager();

59% of this comment could be valid code. Did you maybe forget this after debugging?

		//$event  = $events->getEvent(AuthEvent::EVENT_USER_REGISTERED, $this);

57% of this comment could be valid code. Did you maybe forget this after debugging?

		//$event->setUser($user);

86% of this comment could be valid code. Did you maybe forget this after debugging?

		//$events->triggerEvent($event);

86% of this comment could be valid code. Did you maybe forget this after debugging?

		return $user;
	}
	
	/**
	 * @When I have :organization as my main organization
	 * @param $orgName
	 */
	public function iHaveMainOrganization(UserInterface $user,$orgName)
	{
		/* @var $repoOrganization OrganizationRepository */
		$repoOrganization = $this->coreContext->getRepositories()->get('Organizations/Organization');
		$result = $repoOrganization->findByName($orgName);
		$organization = count($result) > 0 ? $result[0]:null;
		if(!$organization instanceof Organization){

This code seems to be duplicated across your project.

			$organization = new Organization();
			$organizationName = new OrganizationName($orgName);
			$organization->setOrganizationName($organizationName);
		}
        $organization->setProfileSetting(Organization::PROFILE_ALWAYS_ENABLE);
        $permissions = $organization->getPermissions();
        $permissions->grant($user,Permissions::PERMISSION_ALL);

        $organization->setUser($user);
        $repoOrganization->store($organization);
        $repoOrganization->getDocumentManager()->refresh($organization);

        $this->mainOrganization = $organization;
	}

    /**
     * @return Organization
     */
    public function getMainOrganization()
    {
        return $this->mainOrganization;
    }

	/**
	 * @When I want to log in
	 */
	public function iWantToLogIn()
	{
		$session = $this->minkContext->getSession();
		$url = $this->buildUrl('lang/auth');
		$session->visit($url);
	}
	
	/**
	 * @When I specify the username as :username
	 */
	public function iSpecifyTheUsernameAs($username)
	{
		$this->minkContext->fillField('Login name',$username);
	}
	
	/**
	 * @When I specify the password as :password
	 */
	public function iSpecifyThePasswordAs($password)
	{
		$this->minkContext->fillField('Password',$password);
	}
	
	/**
	 * @Given I am logged in as :username identified by :password
	 */
	public function iAmLoggedInAsIdentifiedBy($username, $password)
	{
		$repo = $this->getUserRepository();
		$user = $repo->findByLogin($username);
		
		if(!$user instanceof User){
			throw new \Exception(sprintf('There is no user with this login: "%s"',$username));
		}
		$this->iWantToLogIn();
		$this->iSpecifyTheUsernameAs($username);
		$this->iSpecifyThePasswordAs($password);
		$this->iLogIn();
        $this->currentUser = $user;
	}
	
	/**
	 * @When I log in
	 */
	public function iLogIn()
	{
		$this->minkContext->pressButton('login');
	}
	
	/**
	 * @When I press logout link
	 */
	public function iPressLogoutLink()
	{
		$url = $this->buildUrl('auth-logout');
		$this->visit($url);
	}
	
	/**
	 * @Given I log in with username :username and password :password
	 */
	public function iLogInWith($username, $password)
	{
		$repo = $this->getUserRepository();
		$user = $repo->findByLogin($username);
		$this->iWantToLogIn();
		$this->iSpecifyTheUsernameAs($username);
		$this->iSpecifyThePasswordAs($password);
		$this->iLogIn();
		$this->loggedInUser = $user;
	}
	
	/**
	 * @When I go to profile page
	 */
	public function iGoToProfilePage()
	{
		$url = $this->buildUrl('lang/my');
		$this->visit($url);
	}
	
	/**
	 * @Given there is a user with the following:
	 */
	public function thereIsAUserWithTheFollowing(TableNode $table)
	{
		$repo = $this->getUserRepository();
		$data = $table->getRowsHash();
		$email = isset($data['email']) ? $data['email']:'test@example.com';
		$password = isset($data['password']) ? $data['password']:'test';
		$fullname = isset($data['fullname']) ? $data['fullname']:'Test User';
		$role = isset($data['role']) ? $data['role']:User::ROLE_RECRUITER;
		
		if(!is_object($user=$repo->findByLogin($email))){
			$user = $this->createUser($email,$password,$role,$fullname);
		}
		$this->currentUser = $user;

It seems like $user of type object<Core\Entity\EntityInterface> or object<Auth\Entity\UserInterface> is incompatible with the declared type object<Auth\Entity\User> of property $currentUser.

		$this->addCreatedUser($user);

It seems like $user can also be of type object<Core\Entity\EntityInterface>; however, Yawik\Behat\UserContext::addCreatedUser() does only seem to accept object<Auth\Entity\UserInterface>, maybe add an additional type check?

	}
	
	private function addCreatedUser(UserInterface $user)
	{
		if(!in_array($user,static::$users)){

Since $users is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $users to at least protected.

			static::$users[] = $user;

Since $users is declared private, accessing it with static will lead to errors in possible sub-classes; consider using self, or increasing the visibility of $users to at least protected.

		}
	}
	
	/**
	 * @When I want to change my password
	 */
	public function iWantToChangeMyPassword()
	{
		$url = $this->buildUrl('lang/my-password');
		$this->visit($url);
	}

    /**
     * @return User
     * @throws FailedExpectationException
     */
	public function getCurrentUser()
    {
        if(!$this->currentUser instanceof User){
            throw new FailedExpectationException('Need to login first before use this step');
        }
        return $this->currentUser;
    }
}