Astuce rapide: tester les applications Symfony avec une base de données jetable

Points clés

• La base de données en mémoire n'existe que dans la mémoire d'application et est une solution pratique pour tester le code qui interagit avec la base de données. Ils sont faciles à configurer avec des applications Symfony en utilisant la doctrine et sont idéales pour les tests en raison de leur redopabilité.
• La configuration de l'environnement de test de Symfony permet la création de bases de données de tests redoutables. Le fichier de configuration qui doit être modifié pour définir ces bases de données est app/config/config_test.php. La prise en charge des bases de données en mémoire à l'aide de SQLite3 peut faciliter les tests en envoyant des requêtes SQL aux bases de données fonctionnelles, éliminant la nécessité de se moquer des classes de référentiel.
• Lorsque vous utilisez une base de données en mémoire dans une classe de test, le schéma doit être construit en premier, ce qui signifie que les tableaux de l'entité et tous les correctifs requis doivent être chargés pour la suite de tests. Le chargeur de démarrage de la base de données peut être utilisé pour effectuer la plupart des travaux, similaire à forcer la commande de la console de mise à jour du mode Doctrine.

Tester le code qui interagit avec une base de données peut être très douloureux. Certains développeurs se moquent des abstractions de la base de données, il n'y a donc pas de requête réelle à tester. D'autres développeurs créent des bases de données de test pour les environnements de développement, mais cela peut également être douloureux en termes d'intégration continue et de maintien de l'état de cette base de données. La base de données en mémoire est une alternative à ces options. Comme ils ne sont présents que dans la mémoire de l'application, ils sont vraiment uniques et très adaptés aux tests. Heureusement, ceux-ci sont très faciles à configurer avec des applications Symfony qui utilisent la doctrine. Essayez de lire notre guide sur les tests fonctionnels avec Symfony pour comprendre le comportement de bout en bout des applications de test.

Configuration de l'environnement Symfony

L'une des fonctionnalités les plus puissantes du cadre Symfony est la possibilité de créer des environnements différents avec leurs propres configurations uniques. Les développeurs de Symfony peuvent ignorer cette fonctionnalité, en particulier les aspects moins connus des environnements de test étudiés ici. Le guide de Symfony sur la maîtrise et la création de nouveaux environnements explique comment les cadres gèrent les configurations de différents environnements et montrent quelques exemples utiles. Le fichier de configuration qui doit être modifié pour définir la base de données de test redoutable est app/config/config_test.php. Lorsque vous accédez à une application dans une suite de tests, le noyau se chargera à l'aide de l'environnement de test et ce fichier de configuration sera traité.

Base de données en mémoire à l'aide de la doctrine

SQLITE3 prend en charge les bases de données en mémoire et convient très pour les tests. Avec ces bases de données, vous pouvez tester votre application en envoyant réellement des requêtes SQL à la base de données fonctionnelle, éliminant ainsi la simulation sans effort des classes de référentiel avec un comportement prédéfini. La base de données sera nouvelle au début du test et sera proprement détruite à la fin. Pour remplacer la configuration de la connexion de la doctrine par défaut, vous devez ajouter la ligne suivante au fichier de configuration de l'environnement de test. Si vous avez plusieurs connexions de doctrine configurées dans votre application, vous devrez peut-être le régler un peu pour correspondre.

# app/config/config_test.yml

doctrine:
    dbal:
        driver:  pdo_sqlite
        memory:  true
        charset: UTF8

Utilisation de la base de données dans les classes de test

Lorsque vous utilisez cette nouvelle base de données brillante dans la classe de test, le schéma doit être construit en premier. Cela signifie créer une table d'entités et charger tous les luminaires requis pour la suite de tests. La classe suivante peut être utilisée comme bootstrap de la base de données, qui fait la plupart du travail. Il a le même effet que de forcer la commande de console de mise à jour du mode Doctrine à exécuter.

<?php
namespace Tests\AppBundle;

use Doctrine\ORM\EntityManager;
use Doctrine\ORM\Tools\SchemaTool;
use Symfony\Component\HttpKernel\KernelInterface;

class DatabasePrimer
{
    public static function prime(KernelInterface $kernel)
    {
        // 确保我们处于测试环境中
        if ('test' !== $kernel->getEnvironment()) {
            throw new \LogicException('Primer must be executed in the test environment');
        }

        // 从服务容器获取实体管理器
        $entityManager = $kernel->getContainer()->get('doctrine.orm.entity_manager');

        // 使用我们的实体元数据运行模式更新工具
        $metadatas = $entityManager->getMetadataFactory()->getAllMetadata();
        $schemaTool = new SchemaTool($entityManager);
        $schemaTool->updateSchema($metadatas);

        // 如果您使用的是 Doctrine Fixtures Bundle，您可以在此处加载它们
    }
}

Si vous avez besoin d'un gestionnaire d'entité pour tester la classe, vous devez appliquer le chargeur de démarrage:

<?php
namespace Tests\AppBundle;

use Symfony\Bundle\FrameworkBundle\Test\KernelTestCase;
use Tests\AppBundle\DatabasePrimer;

class FooTest extends KernelTestCase
{
    public function setUp()
    {
        self::bootKernel();

        DatabasePrimer::prime(self::$kernel);
    }

    public function testFoo()
    {
        $fooService = self::$kernel->getContainer()->get('app.foo_service');

        // ...
    }
}

Dans l'exemple ci-dessus, le conteneur est utilisé pour faire tester le service. Si ce service dépend du gestionnaire d'entité, il sera construit en utilisant le même gestionnaire d'entité démarré dans la méthode setUp. Si plus de contrôle est nécessaire, comme se moquer d'une autre dépendance, vous pouvez toujours récupérer le gestionnaire d'entité du conteneur et l'utiliser pour une instanciation manuelle de la classe qui doit être testée. L'utilisation d'un bundle de doctrine pour remplir une base de données avec les données de test peut également être une bonne idée, mais cela dépend de votre cas d'utilisation.

(La partie FAQ restante doit être traduite ici pour le garder cohérent avec la structure du texte d'origine)

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!