Vendor update && Started using DoctrineMigrations

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/ClassMetadataMock.php

@@ -0,0 +1,14 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+class ClassMetadataMock extends \Doctrine\ORM\Mapping\ClassMetadata
+{
+    /* Mock API */
+
+    public function setIdGeneratorType($type)
+    {
+        $this->_generatorType = $type;
+    }
+
+}

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/ConnectionMock.php

@@ -0,0 +1,106 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+class ConnectionMock extends \Doctrine\DBAL\Connection
+{
+    private $_fetchOneResult;
+    private $_platformMock;
+    private $_lastInsertId = 0;
+    private $_inserts = array();
+    private $_executeUpdates = array();
+
+    public function __construct(array $params, $driver, $config = null, $eventManager = null)
+    {
+        $this->_platformMock = new DatabasePlatformMock();
+
+        parent::__construct($params, $driver, $config, $eventManager);
+
+        // Override possible assignment of platform to database platform mock
+        $this->_platform = $this->_platformMock;
+    }
+
+    /**
+     * @override
+     */
+    public function getDatabasePlatform()
+    {
+        return $this->_platformMock;
+    }
+
+    /**
+     * @override
+     */
+    public function insert($tableName, array $data, array $types = array())
+    {
+        $this->_inserts[$tableName][] = $data;
+    }
+
+    /**
+     * @override
+     */
+    public function executeUpdate($query, array $params = array(), array $types = array())
+    {
+        $this->_executeUpdates[] = array('query' => $query, 'params' => $params, 'types' => $types);
+    }
+
+    /**
+     * @override
+     */
+    public function lastInsertId($seqName = null)
+    {
+        return $this->_lastInsertId;
+    }
+
+    /**
+     * @override
+     */
+    public function fetchColumn($statement, array $params = array(), $colnum = 0)
+    {
+        return $this->_fetchOneResult;
+    }
+
+    /**
+     * @override
+     */
+    public function quote($input, $type = null)
+    {
+        if (is_string($input)) {
+            return "'" . $input . "'";
+        }
+        return $input;
+    }
+
+    /* Mock API */
+
+    public function setFetchOneResult($fetchOneResult)
+    {
+        $this->_fetchOneResult = $fetchOneResult;
+    }
+
+    public function setDatabasePlatform($platform)
+    {
+        $this->_platformMock = $platform;
+    }
+
+    public function setLastInsertId($id)
+    {
+        $this->_lastInsertId = $id;
+    }
+
+    public function getInserts()
+    {
+        return $this->_inserts;
+    }
+
+    public function getExecuteUpdates()
+    {
+        return $this->_executeUpdates;
+    }
+
+    public function reset()
+    {
+        $this->_inserts = array();
+        $this->_lastInsertId = 0;
+    }
+}

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/DatabasePlatformMock.php

@@ -0,0 +1,97 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+class DatabasePlatformMock extends \Doctrine\DBAL\Platforms\AbstractPlatform
+{
+    private $_sequenceNextValSql = "";
+    private $_prefersIdentityColumns = true;
+    private $_prefersSequences = false;
+
+    /**
+     * @override
+     */
+    public function getNativeDeclaration(array $field) {}
+
+    /**
+     * @override
+     */
+    public function getPortableDeclaration(array $field) {}
+
+    /**
+     * @override
+     */
+    public function prefersIdentityColumns()
+    {
+        return $this->_prefersIdentityColumns;
+    }
+
+    /**
+     * @override
+     */
+    public function prefersSequences()
+    {
+        return $this->_prefersSequences;
+    }
+
+    /** @override */
+    public function getSequenceNextValSQL($sequenceName)
+    {
+        return $this->_sequenceNextValSql;
+    }
+
+    /** @override */
+    public function getBooleanTypeDeclarationSQL(array $field) {}
+
+    /** @override */
+    public function getIntegerTypeDeclarationSQL(array $field) {}
+
+    /** @override */
+    public function getBigIntTypeDeclarationSQL(array $field) {}
+
+    /** @override */
+    public function getSmallIntTypeDeclarationSQL(array $field) {}
+
+    /** @override */
+    protected function _getCommonIntegerTypeDeclarationSQL(array $columnDef) {}
+
+    /** @override */
+    public function getVarcharTypeDeclarationSQL(array $field) {}
+
+    /** @override */
+    public function getClobTypeDeclarationSQL(array $field) {}
+
+    /* MOCK API */
+
+    public function setPrefersIdentityColumns($bool)
+    {
+        $this->_prefersIdentityColumns = $bool;
+    }
+
+    public function setPrefersSequences($bool)
+    {
+        $this->_prefersSequences = $bool;
+    }
+
+    public function setSequenceNextValSql($sql)
+    {
+        $this->_sequenceNextValSql = $sql;
+    }
+
+    public function getName()
+    {
+        return 'mock';
+    }
+
+    protected function initializeDoctrineTypeMappings()
+    {
+
+    }
+    /**
+     * Gets the SQL Snippet used to declare a BLOB column type.
+     */
+    public function getBlobTypeDeclarationSQL(array $field)
+    {
+        throw DBALException::notSupported(__METHOD__);
+    }
+}

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/DriverConnectionMock.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+class DriverConnectionMock implements \Doctrine\DBAL\Driver\Connection
+{
+    public function prepare($prepareString) {}
+    public function query() {}
+    public function quote($input, $type=\PDO::PARAM_STR) {}
+    public function exec($statement) {}
+    public function lastInsertId($name = null) {}
+    public function beginTransaction() {}
+    public function commit() {}
+    public function rollBack() {}
+    public function errorCode() {}
+    public function errorInfo() {}
+}

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/DriverMock.php

@@ -0,0 +1,72 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+
+class DriverMock implements \Doctrine\DBAL\Driver
+{
+    private $_platformMock;
+
+    private $_schemaManagerMock;
+
+    public function connect(array $params, $username = null, $password = null, array $driverOptions = array())
+    {
+        return new DriverConnectionMock();
+    }
+
+    /**
+     * Constructs the Sqlite PDO DSN.
+     *
+     * @return string  The DSN.
+     * @override
+     */
+    protected function _constructPdoDsn(array $params)
+    {
+        return "";
+    }
+
+    /**
+     * @override
+     */
+    public function getDatabasePlatform()
+    {
+        if ( ! $this->_platformMock) {
+            $this->_platformMock = new DatabasePlatformMock;
+        }
+        return $this->_platformMock;
+    }
+
+    /**
+     * @override
+     */
+    public function getSchemaManager(\Doctrine\DBAL\Connection $conn)
+    {
+        if($this->_schemaManagerMock == null) {
+            return new SchemaManagerMock($conn);
+        } else {
+            return $this->_schemaManagerMock;
+        }
+    }
+
+    /* MOCK API */
+
+    public function setDatabasePlatform(\Doctrine\DBAL\Platforms\AbstractPlatform $platform)
+    {
+        $this->_platformMock = $platform;
+    }
+
+    public function setSchemaManager(\Doctrine\DBAL\Schema\AbstractSchemaManager $sm)
+    {
+        $this->_schemaManagerMock = $sm;
+    }
+
+    public function getName()
+    {
+        return 'mock';
+    }
+
+    public function getDatabase(\Doctrine\DBAL\Connection $conn)
+    {
+        return;
+    }
+}

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/EntityManagerMock.php

@@ -0,0 +1,106 @@
+<?php
+/*
+ *  $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Tests\Mocks;
+
+use Doctrine\ORM\Proxy\ProxyFactory;
+
+/**
+ * Special EntityManager mock used for testing purposes.
+ */
+class EntityManagerMock extends \Doctrine\ORM\EntityManager
+{
+    private $_uowMock;
+    private $_proxyFactoryMock;
+    private $_idGenerators = array();
+
+    /**
+     * @override
+     */
+    public function getUnitOfWork()
+    {
+        return isset($this->_uowMock) ? $this->_uowMock : parent::getUnitOfWork();
+    }
+
+    /* Mock API */
+
+    /**
+     * Sets a (mock) UnitOfWork that will be returned when getUnitOfWork() is called.
+     *
+     * @param <type> $uow
+     */
+    public function setUnitOfWork($uow)
+    {
+        $this->_uowMock = $uow;
+    }
+
+    public function setProxyFactory($proxyFactory)
+    {
+        $this->_proxyFactoryMock = $proxyFactory;
+    }
+
+    public function getProxyFactory()
+    {
+        return isset($this->_proxyFactoryMock) ? $this->_proxyFactoryMock : parent::getProxyFactory();
+    }
+
+    /**
+     * Mock factory method to create an EntityManager.
+     *
+     * @param unknown_type $conn
+     * @param unknown_type $name
+     * @param Doctrine_Configuration $config
+     * @param Doctrine_EventManager $eventManager
+     * @return Doctrine\ORM\EntityManager
+     */
+    public static function create($conn, \Doctrine\ORM\Configuration $config = null,
+            \Doctrine\Common\EventManager $eventManager = null)
+    {
+        if (is_null($config)) {
+            $config = new \Doctrine\ORM\Configuration();
+            $config->setProxyDir(__DIR__ . '/../Proxies');
+            $config->setProxyNamespace('Doctrine\Tests\Proxies');
+            $config->setMetadataDriverImpl($config->newDefaultAnnotationDriver());
+        }
+        if (is_null($eventManager)) {
+            $eventManager = new \Doctrine\Common\EventManager();
+        }
+
+        return new EntityManagerMock($conn, $config, $eventManager);
+    }
+/*
+    public function setIdGenerator($className, $generator)
+    {
+        $this->_idGenerators[$className] = $generator;
+    }
+*/
+    /** @override */
+/*    public function getIdGenerator($className)
+    {
+
+        if (isset($this->_idGenerators[$className])) {
+            return $this->_idGenerators[$className];
+        }
+
+        return parent::getIdGenerator($className);
+    }
+ */
+}

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/EntityPersisterMock.php

@@ -0,0 +1,100 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+/**
+ * EntityPersister implementation used for mocking during tests.
+ */
+class EntityPersisterMock extends \Doctrine\ORM\Persisters\BasicEntityPersister
+{
+    private $_inserts = array();
+    private $_updates = array();
+    private $_deletes = array();
+    private $_identityColumnValueCounter = 0;
+    private $_mockIdGeneratorType;
+    private $_postInsertIds = array();
+    private $existsCalled = false;
+
+    /**
+     * @param <type> $entity
+     * @return <type>
+     * @override
+     */
+    public function insert($entity)
+    {
+        $this->_inserts[] = $entity;
+        if ( ! is_null($this->_mockIdGeneratorType) && $this->_mockIdGeneratorType == \Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_IDENTITY
+                || $this->_class->isIdGeneratorIdentity()) {
+            $id = $this->_identityColumnValueCounter++;
+            $this->_postInsertIds[$id] = $entity;
+            return $id;
+        }
+        return null;
+    }
+
+    public function addInsert($entity)
+    {
+        $this->_inserts[] = $entity;
+        if ( ! is_null($this->_mockIdGeneratorType) && $this->_mockIdGeneratorType == \Doctrine\ORM\Mapping\ClassMetadata::GENERATOR_TYPE_IDENTITY
+                || $this->_class->isIdGeneratorIdentity()) {
+            $id = $this->_identityColumnValueCounter++;
+            $this->_postInsertIds[$id] = $entity;
+            return $id;
+        }
+        return null;
+    }
+
+    public function executeInserts()
+    {
+        return $this->_postInsertIds;
+    }
+
+    public function setMockIdGeneratorType($genType)
+    {
+        $this->_mockIdGeneratorType = $genType;
+    }
+
+    public function update($entity)
+    {
+        $this->_updates[] = $entity;
+    }
+
+    public function exists($entity, array $extraConditions = array())
+    {
+        $this->existsCalled = true;
+    }
+
+    public function delete($entity)
+    {
+        $this->_deletes[] = $entity;
+    }
+
+    public function getInserts()
+    {
+        return $this->_inserts;
+    }
+
+    public function getUpdates()
+    {
+        return $this->_updates;
+    }
+
+    public function getDeletes()
+    {
+        return $this->_deletes;
+    }
+
+    public function reset()
+    {
+        $this->existsCalled = false;
+        $this->_identityColumnValueCounter = 0;
+        $this->_inserts = array();
+        $this->_updates = array();
+        $this->_deletes = array();
+    }
+
+    public function isExistsCalled()
+    {
+        return $this->existsCalled;
+    }
+}

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/HydratorMockStatement.php

@@ -0,0 +1,111 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+/**
+ * This class is a mock of the Statement interface that can be passed in to the Hydrator
+ * to test the hydration standalone with faked result sets.
+ *
+ * @author  Roman Borschel <roman@code-factory.org>
+ */
+class HydratorMockStatement implements \IteratorAggregate, \Doctrine\DBAL\Driver\Statement
+{
+    private $_resultSet;
+
+    /**
+     * Creates a new mock statement that will serve the provided fake result set to clients.
+     *
+     * @param array $resultSet  The faked SQL result set.
+     */
+    public function __construct(array $resultSet)
+    {
+        $this->_resultSet = $resultSet;
+    }
+
+    /**
+     * Fetches all rows from the result set.
+     *
+     * @return array
+     */
+    public function fetchAll($fetchStyle = null, $columnIndex = null, array $ctorArgs = null)
+    {
+        return $this->_resultSet;
+    }
+
+    public function fetchColumn($columnNumber = 0)
+    {
+        $row = current($this->_resultSet);
+        if ( ! is_array($row)) return false;
+        $val = array_shift($row);
+        return $val !== null ? $val : false;
+    }
+
+    /**
+     * Fetches the next row in the result set.
+     *
+     */
+    public function fetch($fetchStyle = null)
+    {
+        $current = current($this->_resultSet);
+        next($this->_resultSet);
+        return $current;
+    }
+
+    /**
+     * Closes the cursor, enabling the statement to be executed again.
+     *
+     * @return boolean
+     */
+    public function closeCursor()
+    {
+        return true;
+    }
+
+    public function setResultSet(array $resultSet)
+    {
+        reset($resultSet);
+        $this->_resultSet = $resultSet;
+    }
+
+    public function bindColumn($column, &$param, $type = null)
+    {
+    }
+
+    public function bindValue($param, $value, $type = null)
+    {
+    }
+
+    public function bindParam($column, &$variable, $type = null, $length = null, $driverOptions = array())
+    {
+    }
+
+    public function columnCount()
+    {
+    }
+
+    public function errorCode()
+    {
+    }
+
+    public function errorInfo()
+    {
+    }
+
+    public function execute($params = array())
+    {
+    }
+
+    public function rowCount()
+    {
+    }
+
+    public function getIterator()
+    {
+        return $this->_resultSet;
+    }
+
+    public function setFetchMode($fetchMode)
+    {
+
+    }
+}

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/IdentityIdGeneratorMock.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+class IdentityIdGeneratorMock extends \Doctrine\ORM\Id\IdentityGenerator
+{
+    private $_mockPostInsertId;
+
+    public function setMockPostInsertId($id) {
+        $this->_mockPostInsertId = $id;
+    }
+}

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/MetadataDriverMock.php

@@ -0,0 +1,21 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+class MetadataDriverMock implements \Doctrine\ORM\Mapping\Driver\Driver
+{
+    public function loadMetadataForClass($className, \Doctrine\ORM\Mapping\ClassMetadataInfo $metadata)
+    {
+        return;
+    }
+
+    public function isTransient($className)
+    {
+        return false;
+    }
+
+    public function getAllClassNames()
+    {
+        return array();
+    }
+}

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/MockTreeWalker.php

@@ -0,0 +1,17 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+class MockTreeWalker extends \Doctrine\ORM\Query\TreeWalkerAdapter
+{
+    /**
+     * Gets an executor that can be used to execute the result of this walker.
+     *
+     * @return AbstractExecutor
+     */
+    public function getExecutor($AST)
+    {
+        return null;
+    }
+}
+

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/SchemaManagerMock.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+class SchemaManagerMock extends \Doctrine\DBAL\Schema\AbstractSchemaManager
+{
+    public function __construct(\Doctrine\DBAL\Connection $conn)
+    {
+        parent::__construct($conn);
+    }
+
+    protected function _getPortableTableColumnDefinition($tableColumn) {}
+}

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/SequenceMock.php

@@ -0,0 +1,52 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+use Doctrine\ORM\EntityManager;
+
+class SequenceMock extends \Doctrine\ORM\Id\SequenceGenerator
+{
+    private $_sequenceNumber = 0;
+
+    public function generate(EntityManager $em, $entity)
+    {
+        return $this->_sequenceNumber++;
+    }
+
+    /**
+     * @override
+     */
+    public function nextId($seqName, $ondemand = true)
+    {
+        return $this->_sequenceNumber++;
+    }
+
+    /**
+     * @override
+     */
+    public function lastInsertId($table = null, $field = null)
+    {
+        return $this->_sequenceNumber - 1;
+    }
+
+    /**
+     * @override
+     */
+    public function currId($seqName)
+    {
+        return $this->_sequenceNumber;
+    }
+
+    /* Mock API */
+
+    public function reset()
+    {
+        $this->_sequenceNumber = 0;
+    }
+
+    public function autoinc()
+    {
+        $this->_sequenceNumber++;
+    }
+}
+

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/TaskMock.php

@@ -0,0 +1,81 @@
+<?php
+/*
+ *  $Id$
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * This software consists of voluntary contributions made by many individuals
+ * and is licensed under the LGPL. For more information, see
+ * <http://www.doctrine-project.org>.
+ */
+
+namespace Doctrine\Tests\Mocks;
+
+use Doctrine\Common\Cli\AbstractNamespace;
+
+/**
+ * TaskMock used for testing the CLI interface.
+ * @author Nils Adermann <naderman@naderman.de>
+ */
+class TaskMock extends \Doctrine\Common\Cli\Tasks\AbstractTask
+{
+    /**
+     * Since instances of this class can be created elsewhere all instances
+     * register themselves in this array for later inspection.
+     *
+     * @var array(TaskMock)
+     */
+    static public $instances = array();
+
+    private $runCounter = 0;
+
+    /**
+     * Constructor of Task Mock Object.
+     * Makes sure the object can be inspected later.
+     *
+     * @param AbstractNamespace CLI Namespace, passed to parent constructor
+     */
+    function __construct(AbstractNamespace $namespace)
+    {
+        self::$instances[] = $this;
+
+        parent::__construct($namespace);
+    }
+
+    /**
+     * Returns the number of times run() was called on this object.
+     *
+     * @return int
+     */
+    public function getRunCounter()
+    {
+        return $this->runCounter;
+    }
+
+    /* Mock API */
+
+    /**
+     * Method invoked by CLI to run task.
+     */
+    public function run()
+    {
+        $this->runCounter++;
+    }
+
+    /**
+     * Method supposed to generate the CLI Task Documentation
+     */
+    public function buildDocumentation()
+    {
+    }
+}

vendor/doctrine/orm/tests/Doctrine/Tests/Mocks/UnitOfWorkMock.php

@@ -0,0 +1,58 @@
+<?php
+
+namespace Doctrine\Tests\Mocks;
+
+class UnitOfWorkMock extends \Doctrine\ORM\UnitOfWork
+{
+    private $_mockDataChangeSets = array();
+    private $_persisterMock;
+
+    /**
+     * @override
+     */
+    public function getEntityPersister($entityName)
+    {
+        return isset($this->_persisterMock[$entityName]) ?
+                $this->_persisterMock[$entityName] : parent::getEntityPersister($entityName);
+    }
+
+    /**
+     * @param <type> $entity
+     * @override
+     */
+    public function getEntityChangeSet($entity)
+    {
+        $oid = spl_object_hash($entity);
+        return isset($this->_mockDataChangeSets[$oid]) ?
+                $this->_mockDataChangeSets[$oid] : parent::getEntityChangeSet($entity);
+    }
+
+    /* MOCK API */
+
+    /**
+     * Sets a (mock) persister for an entity class that will be returned when
+     * getEntityPersister() is invoked for that class.
+     *
+     * @param <type> $entityName
+     * @param <type> $persister
+     */
+    public function setEntityPersister($entityName, $persister)
+    {
+        $this->_persisterMock[$entityName] = $persister;
+    }
+
+    public function setDataChangeSet($entity, array $mockChangeSet)
+    {
+        $this->_mockDataChangeSets[spl_object_hash($entity)] = $mockChangeSet;
+    }
+
+    public function setEntityState($entity, $state)
+    {
+        $this->_entityStates[spl_object_hash($entity)] = $state;
+    }
+
+    public function setOriginalEntityData($entity, array $originalData)
+    {
+        $this->_originalEntityData[spl_object_hash($entity)] = $originalData;
+    }
+}