Dans cet article, nous discuterons du processus de test des correctifs de base de données à l’aide de tSQLt, un framework de test unitaire SQL. Nous vous guiderons à travers les étapes de création et d’exécution de tests pour vérifier un correctif avant son application à la base de données. De plus, nous fournirons une compréhension conceptuelle des correctifs de base de données et mettrons en évidence la flexibilité de tSQLt pour les tests de correctifs simples.

Compréhension des correctifs de base de données

Un correctif de base de données est une modification appliquée à une base de données de production pour résoudre un problème existant ou potentiel lié à la cohérence, à l’intégrité ou aux performances des données. Il peut être appliqué de différentes manières, telles que l’exécution d’un script T-SQL, l’utilisation de SQL Server Management Studio (SSMS) ou la création et l’exécution d’un package SSIS. Cependant, avant d’appliquer un correctif, il est crucial de le tester pour en assurer l’efficacité.

Le cycle de test des correctifs

Le cycle de test des correctifs implique généralement les étapes suivantes :

1. Un bogue est détecté dans la base de données de production.
2. Un correctif est rédigé pour résoudre le problème.
3. Le correctif est testé pour s’assurer qu’il fonctionne correctement.
4. Si le test est réussi, le correctif est appliqué à la base de données de production.
5. Si le test échoue, le correctif est modifié davantage.
6. Il est recommandé de tester la base de données de production après l’application du correctif.

Mise en place du test de correctif avec tSQLt

Pour commencer le test de correctif avec tSQLt, vous avez besoin d’une base de données d’exemple et du framework tSQLt installé dessus. Il est important de noter que tSQLt ne doit être installé que sur les bases de données de développement et non sur les bases de production ou de QA.

Vous pouvez créer une base de données d’exemple nommée SQLDevArticlesFixes en exécutant le code T-SQL suivant :

-- Créer la base de données SQLDevArticlesFixes
CREATE DATABASE SQLDevArticlesFixes;
GO

USE SQLDevArticlesFixes;
GO

-- Créer la table des auteurs
CREATE TABLE [dbo].[Author] (
    [AuthorId] INT IDENTITY(1,1) NOT NULL,
    [Name] VARCHAR(40) NOT NULL,
    [RegistrationDate] DATETIME2(7) NULL
);

-- Créer les tables des articles
CREATE TABLE [dbo].[Article] (
    [ArticleId] INT IDENTITY(1,1) NOT NULL,
    [Title] VARCHAR(300) NOT NULL,
    [Published_Date] DATETIME2(7) NOT NULL
);

-- Remplir la table des auteurs
SET IDENTITY_INSERT [dbo].[Author] ON
INSERT INTO [dbo].[Author] ([AuthorId], [Name], [RegistrationDate])
VALUES (1, N'Asif', N'2018-01-01 00:00:00'),
       (2, N'Peter', N'2018-02-01 00:00:00'),
       (3, N'Sarah', N'2018-03-02 00:00:00'),
       (4, N'Adil', N'2018-04-02 00:00:00'),
       (5, N'Sam', N'2019-01-01 00:00:00');
SET IDENTITY_INSERT [dbo].[Author] OFF

-- Remplir la table des articles
SET IDENTITY_INSERT [dbo].[Article] ON
INSERT INTO [dbo].[Article] ([ArticleId], [Title], [Published_Date])
VALUES (1, N'Fondamentaux de la programmation de base de données', N'2018-01-02 00:00:00'),
       (2, N'Programmation avancée de base de données', N'2018-01-03 00:00:00'),
       (3, N'Compréhension des procédures stockées SQL', N'2018-02-02 00:00:00'),
       (4, N'Concepts de conception de base de données', N'2018-03-02 00:00:00'),
       (5, N'Fondamentaux de Power BI Desktop', N'2019-01-02 00:00:00');
SET IDENTITY_INSERT [dbo].[Article] OFF;
GO

Une fois la base de données d’exemple configurée, vous pouvez installer tSQLt en téléchargeant le fichier tSQLt.class.sql depuis tsqlt.org et en l’exécutant sur la base de données SQLDevArticlesFixes. Alternativement, vous pouvez l’installer en cliquant sur ce lien : tSQLt_V1.0.5873.27393.

Après une installation réussie, vous pouvez exécuter tous les tests unitaires SQL en exécutant la commande suivante :

-- Exécuter tous les tests unitaires de la base de données
EXEC tsqlt.RunAll;

Si la sortie est conforme aux attentes, tSQLt a été configuré avec succès pour le test de correctif.

Tester un correctif avec tSQLt

Maintenant que la configuration est terminée, nous pouvons créer et exécuter des tests unitaires SQL sur notre base de données d’exemple pour tester un correctif. Supposons que nous devons modifier toutes les dates d’inscription des auteurs du 1er janvier au 2 janvier, mais uniquement pour les années 2019 et 2020.

Nous pouvons créer une procédure stockée nommée Jan01ToJan02HotFix pour appliquer ce correctif. Voici le code de la procédure stockée :

CREATE PROCEDURE [dbo].[Jan01ToJan02HotFix]
AS
BEGIN
    -- Correctif : Modifier toutes les dates d'inscription du 01 Jan 2019/2020 au 02 Jan 2019/2020
    SET NOCOUNT ON

    UPDATE [dbo].[Author]
    SET [RegistrationDate] = '02 Jan 2019'
    WHERE [RegistrationDate] = '01 Jan 2019'

    UPDATE [dbo].[Author]
    SET [RegistrationDate] = '02 Jan 2020'
    WHERE [RegistrationDate] = '01 Jan 2020'

    SET NOCOUNT OFF
END

Ensuite, nous devons créer une classe de test pour les correctifs. Voici le code pour créer la classe de test :

-- Création de la classe de test pour le correctif
CREATE SCHEMA [HotFixTests] AUTHORIZATION dbo;
GO

EXECUTE sp_addextendedproperty @name = 'tSQLt.TestClass', @value = 1, @level0type = 'SCHEMA', @level0name = 'HotFixTests';

Maintenant, créons un test unitaire SQL pour le correctif. Le test doit vérifier si les dates d’inscription des auteurs sont modifiées correctement. Voici le code du test unitaire SQL :

CREATE PROCEDURE [HotFixTests].[test pour vérifier que Jan01Jan02HotFix s'exécute avec succès]
AS
BEGIN
    -- Ceci est un test unitaire Jan01Jan02HotFix qui vérifie si la date d'inscription du 01 Jan 2019 est modifiée en 02 Jan 2019 et du 01 Jan 2020 est modifiée en 02 Jan 2020

    -- Assembler
    EXEC tSQLt.FakeTable @TableName = 'dbo.Author'; -- Fausse table Author

    INSERT INTO [dbo].[Author] ([AuthorId], [Name], [RegistrationDate])
    VALUES (1, 'Auteur1', '01 Jan 2019'),
           (2, 'Auteur2', '01 Mar 2020'),
           (3, 'Auteur3', '01 Avr 2019'),
           (4, 'Auteur4', '01 Jan 2020')

    CREATE TABLE [HotFixTests].[Expected]
    (
        [AuthorId] INT,
        [Name] VARCHAR(40) NOT NULL,
        [RegistrationDate] DATETIME2 NOT NULL
    )

    INSERT INTO HotFixTests.Expected
    (
        [AuthorId],
        [Name],
        [RegistrationDate]
    )
    VALUES
    (
        1,
        'Auteur1',
        '02 Jan 2019'
    ),
    (
        2,
        'Auteur2',
        '01 Mar 2020'
    ),
    (
        3,
        'Auteur3',
        '01 Avr 2019'
    ),
    (
        4,
        'Auteur4',
        '02 Jan 2020'
    )

    -- Agir
    EXEC dbo.Jan01ToJan02HotFix; -- Exécuter le correctif

    SELECT *
    INTO HotFixTests.Actual
    FROM dbo.Author; -- Mettre les enregistrements de la table Author dans la table Actual

    -- Vérifier (comparer la table attendue avec les résultats de la table réelle)
    EXEC tSQLt.AssertEqualsTable @Expected = 'HotFixTests.Expected', @Actual = 'HotFixTests.Actual'
END

Enfin, vous pouvez exécuter tous les tests unitaires SQL en exécutant la commande suivante :

-- Exécuter tous les tests unitaires de la base de données
EXEC tsqlt.RunAll;

Si les tests réussissent, cela signifie que le correctif a été testé avec succès. Vous pouvez également appliquer le correctif à la base de données d’exemple en exécutant la commande suivante :

-- Exécuter le correctif de base de données
EXEC dbo.Jan01ToJan02HotFix;

Après avoir appliqué le correctif, vous pouvez afficher la table des auteurs pour vérifier les modifications :

-- Afficher la table des auteurs après l'application du correctif
SELECT a.AuthorId, a.Name, a.RegistrationDate
FROM dbo.Author a;

Félicitations ! Vous avez testé avec succès un correctif à l’aide de tSQLt et l’avez appliqué à la base de données d’exemple. tSQLt aide non seulement dans les tests unitaires des objets de base de données, mais joue également un rôle essentiel dans les tests de correctifs SQL. Vous pouvez regrouper les correctifs dans des classes de test distinctes pour référence future et réutilisation. Cependant, pour des correctifs plus complexes, il peut être nécessaire de travailler avec d’autres outils, technologies et équipes pour garantir un test approprié.

Merci d’avoir lu cet article sur le test de correctif SQL Server avec tSQLt. Nous espérons que vous l’avez trouvé informatif et utile dans votre processus de développement de base de données.