RetailCRM-Mirror/doctrine2
1
0
Fork 0
mirror of synced 2025-02-20 22:23:14 +03:00
Code Issues Projects Releases Wiki Activity

#1172 - reverted: moving MergeUninitializedProxyTest tests into EntityManagerTest (invalid, as they are functional tests)

Browse Source
This commit is contained in:
Marco Pivetta 2015-01-16 22:43:03 +01:00
parent 3769cd1119
commit 94724b7a56
1 changed files with 0 additions and 198 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

198
tests/Doctrine/Tests/ORM/EntityManagerTest.php
View File

@ -2,15 +2,6 @@
namespace Doctrine\Tests\ORM;
use Doctrine\DBAL\Logging\DebugStack;
use Doctrine\DBAL\Logging\SQLLogger;
use Doctrine\ORM\Configuration;
use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Tools\SchemaTool;
use Doctrine\ORM\Tools\ToolsException;
use Doctrine\Tests\Models\Generic\DateTimeModel;
use Doctrine\Tests\TestUtil;
class EntityManagerTest extends \Doctrine\Tests\OrmTestCase
{
private $_em;
@ -204,193 +195,4 @@ class EntityManagerTest extends \Doctrine\Tests\OrmTestCase
$this->assertSame($this->_em, $em);
return 'callback';
}
/**
* @group DDC-1392
* @group DDC-1734
* @group DDC-3368
* @group #1172
*/
public function testMergeDetachedUnInitializedProxy()
{
$em = $this->createEntityManager();
$detachedUninitialized = $em->getReference(DateTimeModel::CLASSNAME, 123);
$em->clear();
$managed = $em->getReference(DateTimeModel::CLASSNAME, 123);
$this->assertSame($managed, $em->merge($detachedUninitialized));
$this->assertFalse($managed->__isInitialized());
$this->assertFalse($detachedUninitialized->__isInitialized());
}
public function testMergeUnserializedUnInitializedProxy()
{
$em = $this->createEntityManager();
$detachedUninitialized = $em->getReference(DateTimeModel::CLASSNAME, 123);
$em->clear();
$managed = $em->getReference(DateTimeModel::CLASSNAME, 123);
$this->assertSame(
$managed,
$em->merge(unserialize(serialize($em->merge($detachedUninitialized))))
);
$this->assertFalse($managed->__isInitialized());
$this->assertFalse($detachedUninitialized->__isInitialized());
}
public function testMergeManagedProxy()
{
$em = $this->createEntityManager();
$managed = $em->getReference(DateTimeModel::CLASSNAME, 123);
$this->assertSame($managed, $em->merge($managed));
$this->assertFalse($managed->__isInitialized());
}
public function testMergingProxyFromDifferentEntityManagerWithExistingManagedInstanceDoesNotReplaceInitializer()
{
$em1 = $this->createEntityManager($logger1 = new DebugStack());
$em2 = $this->createEntityManager($logger2 = new DebugStack());
$entity1 = new DateTimeModel();
$entity2 = new DateTimeModel();
$em1->persist($entity1);
$em2->persist($entity2);
$em1->flush();
$em2->flush();
$em1->clear();
$em2->clear();
$queryCount1 = count($logger1->queries);
$queryCount2 = count($logger2->queries);
$proxy1 = $em1->getReference(DateTimeModel::CLASSNAME, $entity1->id);
$proxy2 = $em2->getReference(DateTimeModel::CLASSNAME, $entity1->id);
$merged2 = $em2->merge($proxy1);
$this->assertNotSame($proxy1, $merged2);
$this->assertSame($proxy2, $merged2);
$this->assertFalse($proxy1->__isInitialized());
$this->assertFalse($proxy2->__isInitialized());
$proxy1->__load();
$this->assertCount(
$queryCount1 + 1,
$logger1->queries,
'Loading the first proxy was done through the first entity manager'
);
$this->assertCount(
$queryCount2,
$logger2->queries,
'No queries were executed on the second entity manager, as it is unrelated with the first proxy'
);
$proxy2->__load();
$this->assertCount(
$queryCount1 + 1,
$logger1->queries,
'Loading the second proxy does not affect the first entity manager'
);
$this->assertCount(
$queryCount2 + 1,
$logger2->queries,
'Loading of the second proxy instance was done through the second entity manager'
);
}
public function testMergingUnInitializedProxyDoesNotInitializeIt()
{
$em1 = $this->createEntityManager($logger1 = new DebugStack());
$em2 = $this->createEntityManager($logger2 = new DebugStack());
$entity1 = new DateTimeModel();
$entity2 = new DateTimeModel();
$em1->persist($entity1);
$em2->persist($entity2);
$em1->flush();
$em2->flush();
$em1->clear();
$em2->clear();
$queryCount1 = count($logger1->queries);
$queryCount2 = count($logger1->queries);
$unManagedProxy = $em1->getReference(DateTimeModel::CLASSNAME, $entity1->id);
$mergedInstance = $em2->merge($unManagedProxy);
$this->assertNotInstanceOf('Doctrine\Common\Proxy\Proxy', $mergedInstance);
$this->assertNotSame($unManagedProxy, $mergedInstance);
$this->assertFalse($unManagedProxy->__isInitialized());
$this->assertCount(
$queryCount1,
$logger1->queries,
'Loading the merged instance affected only the first entity manager'
);
$this->assertCount(
$queryCount1 + 1,
$logger2->queries,
'Loading the merged instance was done via the second entity manager'
);
$unManagedProxy->__load();
$this->assertCount(
$queryCount1 + 1,
$logger1->queries,
'Loading the first proxy was done through the first entity manager'
);
$this->assertCount(
$queryCount2 + 1,
$logger2->queries,
'No queries were executed on the second entity manager, as it is unrelated with the first proxy'
);
}
/**
* @param SQLLogger $logger
*
* @return \Doctrine\ORM\EntityManager
*/
private function createEntityManager(SQLLogger $logger = null)
{
$config = new Configuration();
$config->setProxyDir(realpath(__DIR__ . '/../Proxies/../..'));
$config->setProxyNamespace('Doctrine\Tests\Proxies');
$config->setMetadataDriverImpl($config->newDefaultAnnotationDriver(
array(realpath(__DIR__ . '/../Models/Cache')),
true
));
$connection = TestUtil::getConnection();
$connection->getConfiguration()->setSQLLogger($logger);
$entityManager = EntityManager::create($connection, $config);
try {
(new SchemaTool($entityManager))
->createSchema([$entityManager->getClassMetadata(DateTimeModel::CLASSNAME)]);
} catch (ToolsException $ignored) {
// tables were already created
}
return $entityManager;
}
}