Separate db tool and db backup/restore services for version 2.x

README.md

@@ -316,7 +316,18 @@ Tips for Fixture Loading Tests
         cache_sqlite_db: true
     ```
 
- 3. Load your Doctrine fixtures in your tests:
+ 3. For create custom database cache service
+ 
+    **Attention: Don't work with `liip_functional_test.cache_sqlite_db` use only `liip_functional_test.cache_db.*`.**
+    ```yaml
+    # app/config/config_test.yml
+    liip_functional_test:
+        cache_db:
+            sqlite: liip_functional_test.database_backup.sqllite
+            mysql: liip_functional_test.services_database_backup.mysql_custom
+    ```
+ 
+ 4. Load your Doctrine fixtures in your tests:
 
     ```php
     use Liip\FunctionalTestBundle\Test\WebTestCase;
@@ -339,7 +350,7 @@ Tips for Fixture Loading Tests
     }
     ```
 
- 4. If you don't need any fixtures to be loaded and just want to start off with
+ 5. If you don't need any fixtures to be loaded and just want to start off with
     an empty database (initialized with your schema), you can simply call
     `loadFixtures` without any argument.
 
@@ -359,7 +370,7 @@ Tips for Fixture Loading Tests
     }
     ```
 
- 5. Given that you want to exclude some of your doctrine tables from being purged
+ 6. Given that you want to exclude some of your doctrine tables from being purged
     when loading the fixtures, you can do so by passing an array of tablenames 
     to the `setExcludedDoctrineTables` method before loading the fixtures.
 
@@ -379,7 +390,7 @@ Tips for Fixture Loading Tests
     }
     ```
 
- 6. If you want to append fixtures instead of clean database and load them, you have
+ 7. If you want to append fixtures instead of clean database and load them, you have
  to consider use the second parameter $append with value true.
 
     ```php
@@ -398,7 +409,7 @@ Tips for Fixture Loading Tests
         }
     ```
 
- 7. This bundle uses Doctrine ORM by default. If you are using another driver just
+ 8. This bundle uses Doctrine ORM by default. If you are using another driver just
     specify the service id of the registry manager:
 
     ```php

src/DependencyInjection/Configuration.php

@@ -31,6 +31,15 @@ public function getConfigTreeBuilder(): TreeBuilder
         $rootNode
             ->children()
                 ->booleanNode('cache_sqlite_db')->defaultFalse()->end()
+                ->arrayNode('cache_db')
+                    ->addDefaultsIfNotSet()
+                    ->ignoreExtraKeys(false)
+                        ->children()
+                            ->scalarNode('sqlite')
+                            ->defaultNull()
+                        ->end()
+                    ->end()
+                ->end()
                 ->scalarNode('command_verbosity')->defaultValue('normal')->end()
                 ->booleanNode('command_decoration')->defaultTrue()->end()
                 ->arrayNode('query')

src/DependencyInjection/LiipFunctionalTestExtension.php

@@ -33,6 +33,7 @@ public function load(array $configs, ContainerBuilder $container): void
         $loader = new XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
         $loader->load('commands.xml');
         $loader->load('functional_test.xml');
+        $loader->load('database_tools.xml');
         if (interface_exists('Symfony\Component\Validator\Validator\ValidatorInterface')) {
             $loader->load('validator.xml');
         }

src/Resources/config/database_tools.xml

@@ -0,0 +1,55 @@
+<?xml version="1.0" ?>
+
+<container xmlns="http://symfony.com/schema/dic/services"
+           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+           xsi:schemaLocation="http://symfony.com/schema/dic/services http://symfony.com/schema/dic/services/services-1.0.xsd">
+
+    <services>
+        <service id="liip_functional_test.services.fixtures_loader_factory" class="Liip\FunctionalTestBundle\Services\FixturesLoaderFactory" public="true">
+            <argument type="service" id="service_container" />
+        </service>
+
+        <service id="liip_functional_test.services_database_backup.sqlite" class="Liip\FunctionalTestBundle\Services\DatabaseBackup\SqliteDatabaseBackup" public="true">
+            <argument type="service" id="service_container" />
+            <argument type="service" id="liip_functional_test.services.fixtures_loader_factory" />
+        </service>
+
+        <service id="liip_functional_test.services_database_backup.mysql_custom" class="Liip\FunctionalTestBundle\Services\DatabaseBackup\MysqlCustomDatabaseBackup" public="true">
+            <argument type="service" id="service_container" />
+            <argument type="service" id="liip_functional_test.services.fixtures_loader_factory" />
+        </service>
+
+        <service id="liip_functional_test.services_database_tools.ormdatabase_tool" class="Liip\FunctionalTestBundle\Services\DatabaseTools\ORMDatabaseTool" public="false">
+            <argument type="service" id="service_container" />
+            <argument type="service" id="liip_functional_test.services.fixtures_loader_factory" />
+        </service>
+        <service id="liip_functional_test.services_database_tools.ormsqllite_database_tool" class="Liip\FunctionalTestBundle\Services\DatabaseTools\ORMSqlliteDatabaseTool" public="false">
+            <argument type="service" id="service_container" />
+            <argument type="service" id="liip_functional_test.services.fixtures_loader_factory" />
+        </service>
+        <service id="liip_functional_test.services_database_tools.mongo_dbdatabase_tool" class="Liip\FunctionalTestBundle\Services\DatabaseTools\MongoDBDatabaseTool" public="false">
+            <argument type="service" id="service_container" />
+            <argument type="service" id="liip_functional_test.services.fixtures_loader_factory" />
+        </service>
+        <service id="liip_functional_test.services_database_tools.phpcrdatabase_tool" class="Liip\FunctionalTestBundle\Services\DatabaseTools\PHPCRDatabaseTool" public="false">
+            <argument type="service" id="service_container" />
+            <argument type="service" id="liip_functional_test.services.fixtures_loader_factory" />
+        </service>
+        <service id="liip_functional_test.services.database_tool_collection" class="Liip\FunctionalTestBundle\Services\DatabaseToolCollection" public="true">
+            <argument type="service" id="service_container" />
+            <argument type="service" id="liip_functional_test.services.fixtures_loader_factory" />
+            <call method="add">
+                <argument type="service" id="liip_functional_test.services_database_tools.ormdatabase_tool" />
+            </call>
+            <call method="add">
+                <argument type="service" id="liip_functional_test.services_database_tools.ormsqllite_database_tool" />
+            </call>
+            <call method="add">
+                <argument type="service" id="liip_functional_test.services_database_tools.mongo_dbdatabase_tool" />
+            </call>
+            <call method="add">
+                <argument type="service" id="liip_functional_test.services_database_tools.phpcrdatabase_tool" />
+            </call>
+        </service>
+    </services>
+</container>

src/Services/DatabaseBackup/AbstractDatabaseBackup.php

@@ -0,0 +1,116 @@
+<?php
+
+/*
+ * This file is part of the Liip/FunctionalTestBundle
+ *
+ * (c) Lukas Kahwe Smith <[email protected]>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Liip\FunctionalTestBundle\Services\DatabaseBackup;
+
+use Doctrine\Common\DataFixtures\Executor\AbstractExecutor;
+use Doctrine\DBAL\Connection;
+use Liip\FunctionalTestBundle\Services\FixturesLoaderFactory;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * @author Aleksey Tupichenkov <[email protected]>
+ */
+abstract class AbstractDatabaseBackup
+{
+    protected $container;
+
+    protected $fixturesLoaderFactory;
+
+    /**
+     * @var Connection
+     */
+    protected $connection;
+
+    /**
+     * @var array
+     */
+    protected $metadatas;
+
+    /**
+     * The fixture classnames.
+     *
+     * @var array
+     */
+    protected $classNames;
+
+    public function __construct(ContainerInterface $container, FixturesLoaderFactory $fixturesLoaderFactory)
+    {
+        $this->container = $container;
+        $this->fixturesLoaderFactory = $fixturesLoaderFactory;
+    }
+
+    public function init(Connection $connection, array $metadatas, array $classNames): void
+    {
+        $this->connection = $connection;
+        $this->metadatas = $metadatas;
+        $this->classNames = $classNames;
+    }
+
+    abstract public function getBackupName(): string;
+
+    abstract public function isBackupActual(): bool;
+
+    abstract public function backup(AbstractExecutor $executor): void;
+
+    abstract public function restore(AbstractExecutor $executor): void;
+
+    /**
+     * Determine if the Fixtures that define a database backup have been
+     * modified since the backup was made.
+     *
+     * @param string $backup The fixture backup SQLite database file path
+     *
+     * @return bool TRUE if the backup was made since the modifications to the
+     *              fixtures; FALSE otherwise
+     */
+    protected function isBackupUpToDate(string $backup): bool
+    {
+        $backupLastModifiedDateTime = \DateTime::createFromFormat('U', filemtime($backup));
+
+        $loader = $this->fixturesLoaderFactory->getFixtureLoader($this->classNames);
+
+        // Use loader in order to fetch all the dependencies fixtures.
+        foreach ($loader->getFixtures() as $className) {
+            $fixtureLastModifiedDateTime = $this->getFixtureLastModified($className);
+            if ($backupLastModifiedDateTime < $fixtureLastModifiedDateTime) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * This function finds the time when the data blocks of a class definition
+     * file were being written to, that is, the time when the content of the
+     * file was changed.
+     *
+     * @param string $class The fully qualified class name of the fixture class to
+     *                      check modification date on
+     *
+     * @return \DateTime|null
+     */
+    protected function getFixtureLastModified($class): ?\DateTime
+    {
+        $lastModifiedDateTime = null;
+
+        $reflClass = new \ReflectionClass($class);
+        $classFileName = $reflClass->getFileName();
+
+        if (file_exists($classFileName)) {
+            $lastModifiedDateTime = new \DateTime();
+            $lastModifiedDateTime->setTimestamp(filemtime($classFileName));
+        }
+
+        return $lastModifiedDateTime;
+    }
+}

src/Services/DatabaseBackup/MysqlCustomDatabaseBackup.php

@@ -0,0 +1,111 @@
+<?php
+
+/*
+ * This file is part of the Liip/FunctionalTestBundle
+ *
+ * (c) Lukas Kahwe Smith <[email protected]>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+namespace Liip\FunctionalTestBundle\Services\DatabaseBackup;
+
+use Doctrine\Common\DataFixtures\Executor\AbstractExecutor;
+use Doctrine\ORM\EntityManager;
+
+/**
+ * @author Aleksey Tupichenkov <[email protected]>
+ *
+ * It's class created just for example that how to create database backup/restore service
+ */
+class MysqlCustomDatabaseBackup extends AbstractDatabaseBackup
+{
+    protected static $referenceData;
+
+    protected static $sql;
+
+    protected static $metadata;
+
+    public function getBackupName(): string
+    {
+        return $this->container->getParameter('kernel.cache_dir').'/test_mysql_'.md5(serialize($this->metadatas).serialize($this->classNames)).'.sql';
+    }
+
+    public function getReferenceBackupName(): string
+    {
+        return $this->getBackupName().'.ser';
+    }
+
+    protected function getBackup(): string
+    {
+        if (empty(self::$sql)) {
+            self::$sql = file_get_contents($this->getBackupName());
+        }
+
+        return self::$sql;
+    }
+
+    protected function getReferenceBackup(): string
+    {
+        if (empty(self::$referenceData)) {
+            self::$referenceData = file_get_contents($this->getReferenceBackupName());
+        }
+
+        return self::$referenceData;
+    }
+
+    public function isBackupActual(): bool
+    {
+        return
+            file_exists(file_exists($this->getBackupName())) &&
+            file_exists(file_exists($this->getReferenceBackupName())) &&
+            $this->isBackupUpToDate($this->getBackupName());
+    }
+
+    public function backup(AbstractExecutor $executor): void
+    {
+        $params = $this->connection->getParams();
+        if (isset($params['master'])) {
+            $params = $params['master'];
+        }
+
+        $dbName = isset($params['dbname']) ? $params['dbname'] : '';
+        $dbHost = isset($params['host']) ? $params['host'] : '';
+        $dbPort = isset($params['port']) ? $params['port'] : '';
+        $dbUser = isset($params['user']) ? $params['user'] : '';
+        $dbPass = isset($params['password']) ? $params['password'] : '';
+
+        $executor->getReferenceRepository()->save($this->getBackupName());
+        /** @var EntityManager $em */
+        $em = $executor->getReferenceRepository()->getManager();
+        self::$metadata = $em->getMetadataFactory()->getLoadedMetadata();
+
+        exec("mysqldump -h $dbHost -u $dbUser -p$dbPass --no-create-db $dbName > {$this->getBackupName()}");
+    }
+
+    public function restore(AbstractExecutor $executor): void
+    {
+        $this->connection->query('SET FOREIGN_KEY_CHECKS = 0;');
+        $tables = [];
+        foreach ($this->metadatas as $classMetadata) {
+            $tables[] = $classMetadata->table['name'];
+        }
+        $this->connection->query('DROP TABLE IF EXISTS '.implode(',', $tables));
+        $this->connection->query($this->getBackup());
+        $this->connection->query('SET FOREIGN_KEY_CHECKS = 1;');
+
+        /** @var EntityManager $em */
+        $em = $executor->getReferenceRepository()->getManager();
+        if (self::$metadata) {
+            // it need for better performance
+            foreach (self::$metadata as $class => $data) {
+                $em->getMetadataFactory()->setMetadataFor($class, $data);
+            }
+            $executor->getReferenceRepository()->unserialize($this->getReferenceBackup());
+        } else {
+            $executor->getReferenceRepository()->unserialize($this->getReferenceBackup());
+            self::$metadata = $em->getMetadataFactory()->getLoadedMetadata();
+        }
+    }
+}