protected static function setUpEntityManager()
{
$config = new Configuration();
$config->setSQLLogger(null);
$config->setAutoGenerateProxyClasses(true);
$config->setProxyDir(\sys_get_temp_dir());
$config->setProxyNamespace('Proxies');
$config->setMetadataDriverImpl(static::getMetadataDriverImpl());
$config->setQueryCacheImpl(new ArrayCache());
$config->setMetadataCacheImpl(new ArrayCache());
$dbPath = __DIR__ . '/../db.sqlite';
if (file_exists($dbPath)) {
unlink($dbPath);
}
$connection = ['driver' => 'pdo_sqlite', 'path' => $dbPath];
// Event listeners
$interfaces = DoctrineBundleMapping::getDefaultImplementations();
$evm = new EventManager();
// Resolve entity target subscriber
$rtel = new ResolveTargetEntityListener();
foreach ($interfaces as $model => $implementation) {
$rtel->addResolveTargetEntity($model, $implementation, []);
}
$evm->addEventSubscriber($rtel);
// Load metadata subscriber
$lm = new LoadMetadataSubscriber([], $interfaces);
$evm->addEventSubscriber($lm);
static::$em = EntityManager::create($connection, $config, $evm);
}
protected function setUp()
{
parent::setUp();
$evm = new EventManager();
$evm->addEventSubscriber(new SluggableListener());
$evm->addEventSubscriber(new TreeListener());
$this->getMockSqliteEntityManager($evm);
}
public function __construct()
{
// load database configuration from CodeIgniter
require APPPATH . 'config/database.php';
//A Doctrine Autoloader is needed to load the models
// first argument of classloader is namespace and second argument is path
// setup models/entity namespace
$entityLoader = new ClassLoader('models', APPPATH);
$entityLoader->register();
foreach (glob(APPPATH . 'modules/*', GLOB_ONLYDIR) as $m) {
$module = str_replace(APPPATH . 'modules/', '', $m);
$entityLoader = new ClassLoader($module, APPPATH . 'modules');
$entityLoader->register();
}
//Register proxies namespace
$proxyLoader = new ClassLoader('Proxies', APPPATH . 'Proxies');
$proxyLoader->register();
// Set up caches
$config = new Configuration();
$cache = new ArrayCache();
$config->setMetadataCacheImpl($cache);
$driverImpl = $config->newDefaultAnnotationDriver(array(APPPATH . 'models'));
$config->setMetadataDriverImpl($driverImpl);
$config->setQueryCacheImpl($cache);
// Set up entity
$reader = new AnnotationReader($cache);
$models = array(APPPATH . 'models');
foreach (glob(APPPATH . 'modules/*/models', GLOB_ONLYDIR) as $m) {
array_push($models, $m);
}
$driver = new AnnotationDriver($reader, $models);
$config->setMetadataDriverImpl($driver);
// Setup Gedmo
$cachedAnnotationReader = new Doctrine\Common\Annotations\CachedReader($reader, $cache);
// create a driver chain for metadata reading
$driverChain = new Doctrine\ORM\Mapping\Driver\DriverChain();
// load superclass metadata mapping only, into driver chain
// also registers Gedmo annotations.NOTE: you can personalize it
Gedmo\DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $cachedAnnotationReader);
$event = new EventManager();
$timestampableListener = new TimestampableListener();
$timestampableListener->setAnnotationReader($cachedAnnotationReader);
$event->addEventSubscriber($timestampableListener);
$slugListener = new SluggableListener();
$slugListener->setAnnotationReader($cachedAnnotationReader);
$event->addEventSubscriber($slugListener);
// Proxy configuration
$config->setProxyDir(APPPATH . '/proxies');
$config->setProxyNamespace('Proxies');
// Set up logger
// $logger = new EchoSQLLogger;
// $config->setSQLLogger($logger);
$config->setAutoGenerateProxyClasses(TRUE);
// Database connection information
$connectionOptions = array('driver' => 'pdo_mysql', 'user' => $db['default']['username'], 'password' => $db['default']['password'], 'host' => $db['default']['hostname'], 'dbname' => $db['default']['database']);
// Create EntityManager
$this->em = EntityManager::create($connectionOptions, $config, $event);
}
public function setUp()
{
$this->manager = $this->getContainer()->get('rc_servired.transaction.manager');
$this->eventManager = $this->manager->getEntityManager()->getEventManager();
$this->transaction = new Transaction(time());
$this->subscriber = $this->getMockBuilder('RC\\ServiredBundle\\EventListener\\TransactionSubscriber')->setMethods(array())->setConstructorArgs(array($this->getContainer()->get('event_dispatcher')))->getMock();
$this->subscriber->expects($this->once())->method('getSubscribedEvents')->will($this->returnValue(array('prePersist', 'postPersist')));
$this->eventManager->addEventSubscriber($this->subscriber);
}
protected function setUp()
{
parent::setUp();
$evm = new EventManager();
$translatableListener = new TranslatableListener();
$translatableListener->setTranslatableLocale('en_US');
$evm->addEventSubscriber($translatableListener);
$evm->addEventSubscriber(new TimestampableListener());
$this->getMockSqliteEntityManager($evm);
}
/**
* @return DoctrineEventManager
*/
public function configureEventManager()
{
$eventConfiguration = $this->configuration->get('events');
foreach ($eventConfiguration['listeners'] as $listener => $events) {
$this->eventManager->addEventListener((array) $events, new $listener());
}
foreach ($eventConfiguration['subscribers'] as $subscriber) {
$this->eventManager->addEventSubscriber(new $subscriber());
}
return $this->eventManager;
}
protected function setUp()
{
parent::setUp();
$evm = new EventManager();
$this->translationListener = new TranslationListener();
$this->translationListener->setTranslatableLocale('en_us');
$evm->addEventSubscriber(new SluggableListener());
$evm->addEventSubscriber($this->translationListener);
$this->getMockSqliteEntityManager($evm);
$this->populate();
}
protected function setUp()
{
parent::setUp();
$evm = new EventManager();
$translatableListener = new TranslatableListener();
$translatableListener->setTranslatableLocale('en_US');
$evm->addEventSubscriber($translatableListener);
$blameableListener = new BlameableListener();
$blameableListener->setUserValue('testuser');
$evm->addEventSubscriber($blameableListener);
$this->getMockSqliteEntityManager($evm);
}
protected function setUp()
{
parent::setUp();
$evm = new EventManager();
$sluggableListener = new SluggableListener();
$sluggableListener->addManagedFilter(self::SOFT_DELETEABLE_FILTER_NAME, true);
$evm->addEventSubscriber($sluggableListener);
$this->softDeleteableListener = new SoftDeleteableListener();
$evm->addEventSubscriber($this->softDeleteableListener);
$config = $this->getMockAnnotatedConfig();
$config->addFilter(self::SOFT_DELETEABLE_FILTER_NAME, 'Gedmo\\SoftDeleteable\\Filter\\SoftDeleteableFilter');
$this->em = $this->getMockSqliteEntityManager($evm, $config);
$this->em->getFilters()->enable(self::SOFT_DELETEABLE_FILTER_NAME);
}
public function createService(ServiceLocatorInterface $sl)
{
/** @var $options \DoctrineModule\Options\EventManager */
$options = $this->getOptions($sl, 'eventmanager');
$evm = new EventManager();
foreach ($options->getSubscribers() as $subscriber) {
if (is_subclass_of($subscriber, 'Doctrine\\Common\\EventSubscriber')) {
$evm->addEventSubscriber(new $subscriber());
} else {
$evm->addEventSubscriber($sl->get($subscriber));
}
}
return $evm;
}
public function setUp()
{
$evm = new EventManager();
$evm->addEventSubscriber(new DoctrineEncryptSubscriber(new \Doctrine\Common\Annotations\AnnotationReader(), new Rot13Encryptor()));
$this->getMockSqliteEntityManager($evm);
$this->populate();
}
public function setUp()
{
parent::setUp();
$evm = new EventManager();
$evm->addEventSubscriber(new TsVectorSubscriber());
// $this->getMock
}
protected function setUp()
{
parent::setUp();
$evm = new EventManager();
$evm->addEventSubscriber(new TimestampableListener());
$this->getMockDocumentManager($evm);
}
protected function setUp()
{
$config = new Configuration();
//$config->setHydratorDir(sys_get_temp_dir());
//$config->setHydratorNamespace('Hydrators');
$config->setProxyDir(sys_get_temp_dir());
$config->setProxyNamespace('Proxies');
$locatorXml = new SymfonyFileLocator(array(__DIR__ . '/../../../../../lib/Vespolina/Product/Mapping' => 'Vespolina\\Entity\\Product', __DIR__ . '/../../../../../vendor/vespolina/pricing/lib/Vespolina/Pricing/Mapping' => 'Vespolina\\Entity\\Pricing', __DIR__ . '/../../../../../vendor/vespolina/taxonomy/lib/Vespolina/Taxonomy/Mapping' => 'Vespolina\\Entity\\Taxonomy'), '.orm.xml');
$drivers = new MappingDriverChain();
$xmlDriver = new XmlDriver($locatorXml);
$config->setMetadataDriverImpl($xmlDriver);
$config->setMetadataCacheImpl(new ArrayCache());
$config->setAutoGenerateProxyClasses(true);
$eventManager = new EventManager();
$treeListener = new TreeListener();
$eventManager->addEventSubscriber($treeListener);
$em = EntityManager::create(array('driver' => 'pdo_sqlite', 'path' => 'database.sqlite'), $config, $eventManager);
$schemaTool = new \Doctrine\ORM\Tools\SchemaTool($em);
$classes = array($em->getClassMetadata('Vespolina\\Entity\\Product\\Product'), $em->getClassMetadata('Vespolina\\Entity\\Taxonomy\\TaxonomyNode'));
try {
$schemaTool->dropSchema(array());
$schemaTool->createSchema($classes);
} catch (\Exception $e) {
}
$this->productGateway = new ProductDoctrineORMGateway($em, 'Vespolina\\Entity\\Product\\Product');
$this->taxonomyGateway = new TaxonomyDoctrineORMGateway($em, 'Vespolina\\Entity\\Taxonomy\\TaxonomyNode');
parent::setUp();
}
/**
* Get entity manager.
*
* @return EntityManagerInterface
*/
protected function getEntityManager()
{
if (null === $this->entityManager) {
$params = ['driver' => 'pdo_sqlite', 'memory' => true];
$cache = new ArrayCache();
/** @var AnnotationReader $reader */
$reader = new CachedReader(new AnnotationReader(), $cache);
$annotationDriver = new AnnotationDriver($reader, [__DIR__ . '/../../../src/ORM']);
$driverChain = new MappingDriverChain();
$driverChain->addDriver($annotationDriver, Commander::ENTITY_NAMESPACE);
DoctrineExtensions::registerAbstractMappingIntoDriverChainORM($driverChain, $reader);
$config = new Configuration();
$config->setAutoGenerateProxyClasses(true);
$config->setProxyDir(sys_get_temp_dir());
$config->setProxyNamespace(Commander::ENTITY_NAMESPACE);
$config->setMetadataDriverImpl($driverChain);
$config->setMetadataCacheImpl($cache);
$config->setQueryCacheImpl($cache);
$config->setResultCacheImpl($cache);
$config->setHydrationCacheImpl($cache);
$timestampableListener = new TimestampableListener();
$timestampableListener->setAnnotationReader($annotationDriver->getReader());
$eventManager = new EventManager();
$eventManager->addEventSubscriber($timestampableListener);
$entityManager = EntityManager::create($params, $config, $eventManager);
$schemaTool = new SchemaTool($entityManager);
$schemaTool->createSchema($entityManager->getMetadataFactory()->getAllMetadata());
$this->entityManager = $entityManager;
}
return $this->entityManager;
}
/**
* {@inheritdoc}
*/
protected function createWithConfig(ContainerInterface $container, $configKey)
{
$config = $this->retrieveConfig($container, $configKey, 'event_manager');
$eventManager = new EventManager();
foreach ($config['subscribers'] as $subscriber) {
if (is_object($subscriber)) {
$subscriberName = get_class($subscriber);
} elseif (!is_string($subscriber)) {
$subscriberName = gettype($subscriber);
} elseif ($container->has($subscriber)) {
$subscriber = $container->get($subscriber);
$subscriberName = $subscriber;
} elseif (class_exists($subscriber)) {
$subscriber = new $subscriber();
$subscriberName = get_class($subscriber);
} else {
$subscriberName = $subscriber;
}
if (!$subscriber instanceof EventSubscriber) {
throw new DomainException(sprintf('Invalid event subscriber "%s" given, mut be a dependency name, class name or an instance' . ' implementing %s', $subscriberName, EventSubscriber::class));
}
$eventManager->addEventSubscriber($subscriber);
}
return $eventManager;
}
/**
* @param EventManager $manager
* @param EntityManagerInterface $em
* @param Reader $reader
*/
public function addSubscribers(EventManager $manager, EntityManagerInterface $em, Reader $reader)
{
$subscriber = new IpTraceableListener();
$subscriber->setAnnotationReader($reader);
$subscriber->setIpValue($this->request->getClientIp());
$manager->addEventSubscriber($subscriber);
}
protected function setUp()
{
parent::setUp();
$evm = new EventManager();
$this->listener = new UploadableListenerStub();
$this->listener->setMimeTypeGuesser(new MimeTypeGuesserStub('text/plain'));
$evm->addEventSubscriber($this->listener);
$config = $this->getMockAnnotatedConfig();
$this->em = $this->getMockSqliteEntityManager($evm, $config);
$this->testFile = __DIR__ . '/../../data/test.txt';
$this->testFile2 = __DIR__ . '/../../data/test2.txt';
$this->testFile3 = __DIR__ . '/../../data/test_3.txt';
$this->testFileWithoutExt = __DIR__ . '/../../data/test4';
$this->testFileWithSpaces = __DIR__ . '/../../data/test with spaces.txt';
$this->destinationTestDir = __DIR__ . '/../../temp/uploadable';
$this->destinationTestFile = $this->destinationTestDir . '/test.txt';
$this->destinationTestFile2 = $this->destinationTestDir . '/test2.txt';
$this->destinationTestFile3 = $this->destinationTestDir . '/test_3.txt';
$this->destinationTestFileWithoutExt = $this->destinationTestDir . '/test4';
$this->destinationTestFileWithSpaces = $this->destinationTestDir . '/test with spaces';
$this->testFilename = substr($this->testFile, strrpos($this->testFile, '/') + 1);
$this->testFilename2 = substr($this->testFile2, strrpos($this->testFile2, '/') + 1);
$this->testFilename3 = substr($this->testFile3, strrpos($this->testFile3, '/') + 1);
$this->testFilenameWithoutExt = substr($this->testFileWithoutExt, strrpos($this->testFileWithoutExt, '/') + 1);
$this->testFilenameWithSpaces = substr($this->testFileWithSpaces, strrpos($this->testFileWithSpaces, '/') + 1);
$this->testFileSize = 4;
$this->testFileMimeType = 'text/plain';
$this->clearFilesAndDirectories();
if (!is_dir($this->destinationTestDir)) {
mkdir($this->destinationTestDir);
}
}
protected function setUpEntityManager($transformer = null)
{
$evm = new EventManager();
$evm->addEventSubscriber($this->getSubscriber($transformer));
$configuration = Setup::createYAMLMetadataConfiguration([__DIR__ . '/Fixture']);
$this->em = $this->getMockSqliteEntityManager($evm, $configuration);
}
/**
* @param MappedEventSubscriber $subscriber
* @param EventManager $manager
* @param Reader|null $reader
*/
protected function addSubscriber(MappedEventSubscriber $subscriber, EventManager $manager, Reader $reader = null)
{
if ($reader) {
$subscriber->setAnnotationReader($reader);
}
$manager->addEventSubscriber($subscriber);
}
/**
*
* @param \Zend\ServiceManager\ServiceLocatorInterface $serviceLocator
* @return object
*/
public function createService(ServiceLocatorInterface $serviceLocator)
{
$manifest = $serviceLocator->get('manifest');
$config = new Configuration();
$config->setProxyDir(__DIR__ . '/../../../../Proxies');
$config->setProxyNamespace('Proxies');
$config->setHydratorDir(__DIR__ . '/../../../../Hydrators');
$config->setHydratorNamespace('Hydrators');
$config->setDefaultDB(self::DEFAULT_DB);
$config->setMetadataCacheImpl(new ArrayCache());
//create driver chain
$chain = new MappingDriverChain();
foreach ($manifest['documents'] as $namespace => $path) {
$driver = new AnnotationDriver(new AnnotationReader(), $path);
$chain->addDriver($driver, $namespace);
}
$config->setMetadataDriverImpl($chain);
//register filters
foreach ($manifest['filters'] as $name => $class) {
$config->addFilter($name, $class);
}
//create event manager
$eventManager = new EventManager();
foreach ($manifest['subscribers'] as $subscriber) {
$eventManager->addEventSubscriber($serviceLocator->get($subscriber));
}
//register annotations
AnnotationRegistry::registerLoader(function ($className) {
return class_exists($className);
});
$conn = new Connection(null, array(), $config);
return DocumentManager::create($conn, $config, $eventManager);
}
/**
* Add doctrine event manager lifecycle event subscriber
* @throws \Exception
* @param $subscriber
* @return $this
*/
public function addLifecycleEventSubscriber($subscriber)
{
if (empty($this->entityManager)) {
throw new \Exception('Please establish the entity manager connection using getEntityManager prior to adding event subscribers');
}
$this->eventManager->addEventSubscriber($subscriber);
return $this;
}
/**
* @param EventManager $manager
* @param EntityManagerInterface $em
* @param Reader $reader
*/
public function addSubscribers(EventManager $manager, EntityManagerInterface $em, Reader $reader)
{
$subscriber = new TranslatableListener();
$subscriber->setTranslatableLocale($this->application->getLocale());
$subscriber->setDefaultLocale($this->repository->get('app.locale'));
$subscriber->setAnnotationReader($reader);
$manager->addEventSubscriber($subscriber);
}
public function setUp()
{
parent::setUp();
$this->sluggable = new SluggableListener();
$evm = new EventManager();
$evm->addEventSubscriber($this->sluggable);
$this->getMockSqliteEntityManager($evm);
}
protected function getEventManager()
{
$em = new EventManager();
$em->addEventSubscriber(new \Knp\DoctrineBehaviors\ORM\Translatable\TranslatableSubscriber(new ClassAnalyzer(), false, function () {
return 'en';
}, 'Knp\\DoctrineBehaviors\\Model\\Translatable\\Translatable', 'Knp\\DoctrineBehaviors\\Model\\Translatable\\Translation', 'LAZY', 'LAZY'));
return $em;
}
protected function getEventManager()
{
$em = new EventManager();
$em->addEventSubscriber(new \Knp\DoctrineBehaviors\ORM\Translatable\TranslatableListener(function () {
return 'en';
}));
return $em;
}
protected function setUp()
{
parent::setUp();
$evm = new EventManager();
$evm->addEventSubscriber(new SluggableListener());
$this->getMockDocumentManager($evm);
$this->populate();
}
protected function setUp()
{
parent::setUp();
$evm = new EventManager();
$this->encoderListener = new EncoderListener();
$evm->addEventSubscriber($this->encoderListener);
$this->getMockDocumentManager($evm);
}
protected function getEventManager($user = null, $userCallback = null, $userEntity = null)
{
$em = new EventManager();
$this->listener = new \Knp\DoctrineBehaviors\ORM\Blameable\BlameableListener($userCallback, $userEntity);
$this->listener->setUser($user);
$em->addEventSubscriber($this->listener);
return $em;
}
protected function getEventManager($user = null, $userCallback = null, $userEntity = null)
{
$em = new EventManager();
$this->subscriber = new \Knp\DoctrineBehaviors\ORM\Blameable\BlameableSubscriber(new ClassAnalyzer(), false, 'Knp\\DoctrineBehaviors\\Model\\Blameable\\Blameable', $userCallback, $userEntity);
$this->subscriber->setUser($user);
$em->addEventSubscriber($this->subscriber);
return $em;
}
