/var/www/vhosts/nabawater/vendor/codeception/base/src/Codeception/Module
Edit: /var/www/vhosts/nabawater/vendor/codeception/base/src/Codeception/Module/Doctrine2.php (18672B)
true,
'connection_callback' => false,
'depends' => null
];
protected $dependencyMessage = <<
config['connection_callback']) {
return [];
}
return ['Codeception\Lib\Interfaces\DoctrineProvider' => $this->dependencyMessage];
}
public function _inject(DoctrineProvider $dependentModule = null)
{
$this->dependentModule = $dependentModule;
}
public function _beforeSuite($settings = [])
{
$this->retrieveEntityManager();
}
public function _before(TestInterface $test)
{
$this->retrieveEntityManager();
if ($this->config['cleanup']) {
if($this->em->getConnection()->isTransactionActive()) {
try {
while ($this->em->getConnection()->getTransactionNestingLevel() > 0) {
$this->em->getConnection()->rollback();
}
$this->debugSection('Database', 'Transaction cancelled; all changes reverted.');
} catch (\PDOException $e) {
}
}
$this->em->getConnection()->beginTransaction();
$this->debugSection('Database', 'Transaction started');
}
}
/**
* @throws ModuleConfigException
*/
public function onReconfigure()
{
if (!$this->em instanceof \Doctrine\ORM\EntityManagerInterface) {
return;
}
if ($this->config['cleanup'] && $this->em->getConnection()->isTransactionActive()) {
try {
$this->em->getConnection()->rollback();
$this->debugSection('Database', 'Transaction cancelled; all changes reverted.');
} catch (\PDOException $e) {
}
}
$this->clean();
$this->em->getConnection()->close();
$this->retrieveEntityManager();
if ($this->config['cleanup']) {
if($this->em->getConnection()->isTransactionActive()) {
try {
while ($this->em->getConnection()->getTransactionNestingLevel() > 0) {
$this->em->getConnection()->rollback();
}
$this->debugSection('Database', 'Transaction cancelled; all changes reverted.');
} catch (\PDOException $e) {
}
}
$this->em->getConnection()->beginTransaction();
$this->debugSection('Database', 'Transaction started');
}
}
protected function retrieveEntityManager()
{
if ($this->dependentModule) {
$this->em = $this->dependentModule->_getEntityManager();
} else {
if (is_callable($this->config['connection_callback'])) {
$this->em = call_user_func($this->config['connection_callback']);
}
}
if (!$this->em) {
throw new ModuleConfigException(
__CLASS__,
"EntityManager can't be obtained.\n \n"
. "Please specify either `connection_callback` config option\n"
. "with callable which will return instance of EntityManager or\n"
. "pass a dependent module which are Symfony or ZF2\n"
. "to connect to Doctrine using Dependency Injection Container"
);
}
if (!($this->em instanceof \Doctrine\ORM\EntityManagerInterface)) {
throw new ModuleConfigException(
__CLASS__,
"Connection object is not an instance of \\Doctrine\\ORM\\EntityManagerInterface.\n"
. "Use `connection_callback` or dependent framework modules to specify one"
);
}
$this->em->getConnection()->connect();
}
public function _after(TestInterface $test)
{
if (!$this->em instanceof \Doctrine\ORM\EntityManagerInterface) {
return;
}
if ($this->config['cleanup'] && $this->em->getConnection()->isTransactionActive()) {
try {
while ($this->em->getConnection()->getTransactionNestingLevel() > 0) {
$this->em->getConnection()->rollback();
}
$this->debugSection('Database', 'Transaction cancelled; all changes reverted.');
} catch (\PDOException $e) {
}
}
$this->clean();
$this->em->getConnection()->close();
}
protected function clean()
{
$em = $this->em;
$reflectedEm = new \ReflectionClass($em);
if ($reflectedEm->hasProperty('repositories')) {
$property = $reflectedEm->getProperty('repositories');
$property->setAccessible(true);
$property->setValue($em, []);
}
$this->em->clear();
}
/**
* Performs $em->flush();
*/
public function flushToDatabase()
{
$this->em->flush();
}
/**
* Adds entity to repository and flushes. You can redefine it's properties with the second parameter.
*
* Example:
*
* ``` php
* persistEntity(new \Entity\User, array('name' => 'Miles'));
* $I->persistEntity($user, array('name' => 'Miles'));
* ```
*
* @param $obj
* @param array $values
*/
public function persistEntity($obj, $values = [])
{
if ($values) {
$reflectedObj = new \ReflectionClass($obj);
foreach ($values as $key => $val) {
$property = $reflectedObj->getProperty($key);
$property->setAccessible(true);
$property->setValue($obj, $val);
}
}
$this->em->persist($obj);
$this->em->flush();
}
/**
* Mocks the repository.
*
* With this action you can redefine any method of any repository.
* Please, note: this fake repositories will be accessible through entity manager till the end of test.
*
* Example:
*
* ``` php
* haveFakeRepository('Entity\User', array('findByUsername' => function($username) { return null; }));
*
* ```
*
* This creates a stub class for Entity\User repository with redefined method findByUsername,
* which will always return the NULL value.
*
* @param $classname
* @param array $methods
*/
public function haveFakeRepository($classname, $methods = [])
{
$em = $this->em;
$metadata = $em->getMetadataFactory()->getMetadataFor($classname);
$customRepositoryClassName = $metadata->customRepositoryClassName;
if (!$customRepositoryClassName) {
$customRepositoryClassName = '\Doctrine\ORM\EntityRepository';
}
$mock = Stub::make(
$customRepositoryClassName,
array_merge(
[
'_entityName' => $metadata->name,
'_em' => $em,
'_class' => $metadata
],
$methods
)
);
$em->clear();
$reflectedEm = new \ReflectionClass($em);
if ($reflectedEm->hasProperty('repositories')) {
//Support doctrine versions before 2.4.0
$property = $reflectedEm->getProperty('repositories');
$property->setAccessible(true);
$property->setValue($em, array_merge($property->getValue($em), [$classname => $mock]));
} elseif ($reflectedEm->hasProperty('repositoryFactory')) {
//For doctrine 2.4.0+ versions
$repositoryFactoryProperty = $reflectedEm->getProperty('repositoryFactory');
$repositoryFactoryProperty->setAccessible(true);
$repositoryFactory = $repositoryFactoryProperty->getValue($em);
$reflectedRepositoryFactory = new \ReflectionClass($repositoryFactory);
if ($reflectedRepositoryFactory->hasProperty('repositoryList')) {
$repositoryListProperty = $reflectedRepositoryFactory->getProperty('repositoryList');
$repositoryListProperty->setAccessible(true);
$repositoryListProperty->setValue(
$repositoryFactory,
[$classname => $mock]
);
$repositoryFactoryProperty->setValue($em, $repositoryFactory);
} else {
$this->debugSection(
'Warning',
'Repository can\'t be mocked, the EventManager\'s repositoryFactory doesn\'t have "repositoryList" property'
);
}
} else {
$this->debugSection(
'Warning',
'Repository can\'t be mocked, the EventManager class doesn\'t have "repositoryFactory" or "repositories" property'
);
}
}
/**
* Persists record into repository.
* This method creates an entity, and sets its properties directly (via reflection).
* Setters of entity won't be executed, but you can create almost any entity and save it to database.
* Returns id using `getId` of newly created entity.
*
* ```php
* $I->haveInRepository('Entity\User', array('name' => 'davert'));
* ```
*/
public function haveInRepository($entity, array $data)
{
$reflectedEntity = new \ReflectionClass($entity);
$entityObject = $reflectedEntity->newInstance();
foreach ($reflectedEntity->getProperties() as $property) {
/** @var $property \ReflectionProperty */
if (!isset($data[$property->name])) {
continue;
}
$property->setAccessible(true);
$property->setValue($entityObject, $data[$property->name]);
}
$this->em->persist($entityObject);
$this->em->flush();
if (method_exists($entityObject, 'getId')) {
$id = $entityObject->getId();
$this->debug("$entity entity created with id:$id");
return $id;
}
}
/**
* Flushes changes to database, and executes a query with parameters defined in an array.
* You can use entity associations to build complex queries.
*
* Example:
*
* ``` php
* seeInRepository('AppBundle:User', array('name' => 'davert'));
* $I->seeInRepository('User', array('name' => 'davert', 'Company' => array('name' => 'Codegyre')));
* $I->seeInRepository('Client', array('User' => array('Company' => array('name' => 'Codegyre')));
* ?>
* ```
*
* Fails if record for given criteria can\'t be found,
*
* @param $entity
* @param array $params
*/
public function seeInRepository($entity, $params = [])
{
$res = $this->proceedSeeInRepository($entity, $params);
$this->assert($res);
}
/**
* Flushes changes to database and performs `findOneBy()` call for current repository.
*
* @param $entity
* @param array $params
*/
public function dontSeeInRepository($entity, $params = [])
{
$res = $this->proceedSeeInRepository($entity, $params);
$this->assertNot($res);
}
protected function proceedSeeInRepository($entity, $params = [])
{
// we need to store to database...
$this->em->flush();
$data = $this->em->getClassMetadata($entity);
$qb = $this->em->getRepository($entity)->createQueryBuilder('s');
$this->buildAssociationQuery($qb, $entity, 's', $params);
$this->debug($qb->getDQL());
$res = $qb->getQuery()->getArrayResult();
return ['True', (count($res) > 0), "$entity with " . json_encode($params)];
}
/**
* Selects field value from repository.
* It builds query based on array of parameters.
* You can use entity associations to build complex queries.
*
* Example:
*
* ``` php
* grabFromRepository('User', 'email', array('name' => 'davert'));
* ?>
* ```
*
* @version 1.1
* @param $entity
* @param $field
* @param array $params
* @return array
*/
public function grabFromRepository($entity, $field, $params = [])
{
// we need to store to database...
$this->em->flush();
$data = $this->em->getClassMetadata($entity);
$qb = $this->em->getRepository($entity)->createQueryBuilder('s');
$qb->select('s.' . $field);
$this->buildAssociationQuery($qb, $entity, 's', $params);
$this->debug($qb->getDQL());
return $qb->getQuery()->getSingleScalarResult();
}
/**
* Selects entities from repository.
* It builds query based on array of parameters.
* You can use entity associations to build complex queries.
*
* Example:
*
* ``` php
* grabEntitiesFromRepository('AppBundle:User', array('name' => 'davert'));
* ?>
* ```
*
* @version 1.1
* @param $entity
* @param array $params
* @return array
*/
public function grabEntitiesFromRepository($entity, $params = [])
{
// we need to store to database...
$this->em->flush();
$data = $this->em->getClassMetadata($entity);
$qb = $this->em->getRepository($entity)->createQueryBuilder('s');
$qb->select('s');
$this->buildAssociationQuery($qb, $entity, 's', $params);
$this->debug($qb->getDQL());
return $qb->getQuery()->getResult();
}
/**
* Selects a single entity from repository.
* It builds query based on array of parameters.
* You can use entity associations to build complex queries.
*
* Example:
*
* ``` php
* grabEntityFromRepository('User', array('id' => '1234'));
* ?>
* ```
*
* @version 1.1
* @param $entity
* @param array $params
* @return object
*/
public function grabEntityFromRepository($entity, $params = [])
{
// we need to store to database...
$this->em->flush();
$data = $this->em->getClassMetadata($entity);
$qb = $this->em->getRepository($entity)->createQueryBuilder('s');
$qb->select('s');
$this->buildAssociationQuery($qb, $entity, 's', $params);
$this->debug($qb->getDQL());
return $qb->getQuery()->getSingleResult();
}
/**
* It's Fuckin Recursive!
*
* @param $qb
* @param $assoc
* @param $alias
* @param $params
*/
protected function buildAssociationQuery($qb, $assoc, $alias, $params)
{
$data = $this->em->getClassMetadata($assoc);
foreach ($params as $key => $val) {
if (isset($data->associationMappings)) {
if ($map = array_key_exists($key, $data->associationMappings)) {
if (is_array($val)) {
$qb->innerJoin("$alias.$key", "_$key");
foreach ($val as $column => $v) {
if (is_array($v)) {
$this->buildAssociationQuery($qb, $map['targetEntity'], $column, $v);
continue;
}
$paramname = "_$key" . '__' . $column;
$qb->andWhere("_$key.$column = :$paramname");
$qb->setParameter($paramname, $v);
}
continue;
}
}
}
if ($val === null) {
$qb->andWhere("s.$key IS NULL");
} else {
$paramname = str_replace(".", "", "s_$key");
$qb->andWhere("s.$key = :$paramname");
$qb->setParameter($paramname, $val);
}
}
}
public function _getEntityManager()
{
if (is_null($this->em)) {
$this->retrieveEntityManager();
}
return $this->em;
}
}