Testen von Datenbanken - 1 Einführung

Home » BI / SQL » Testen von Datenbanken – 1 Einführung

Testen von Datenbanken – 1 Einführung

24. Februar 2015

Meiner Meinung nach macht es definitiv Sinn, bestimmten Code einer Datenbank zu testen. Ich konzentriere mich dabei eher auf komplexe Verarbeitungen. Einfache CRUD Methoden mit Tests abzudecken schlägt sich meist in steigendem Aufwand nieder. In nachfolgenden Kapiteln möchte ich nun einige Möglichkeiten vorstellen, wie man einen Datenbanktest erstellen könnte.

Ich werde Begriffe wie Systemtest oder Integrationstest vermeiden und von Testfällen und Testszenarien sprechen. Ein Testfall ist ein atomarer Test mit Eingangsdaten, Verarbeitung und einem erwarteten und zu prüfenden Ergebnis. Als Testszenario bezeichne ich mehre Testfälle, die logisch zusammen gehören. Also beispielsweise die gleichen Eingangsdaten verwenden.

Meine Testfälle sind

technisch voneinander unabhängig,
nutzen eine Verbindung zu einer Datenbank,
lesen und schreiben Dateien

und sind sehr wahrscheinlich nicht nach 200ms fertig. Ausführbar sind sie über die Visual Studio Testtools oder auch NUnit und zum Schluss ist jeder einzelne rot oder grün.

Warum existiert komplexer Code in der Datenbank?

Ich verwende gern einfache CRUD Methoden, aber hin und wieder müssen Daten nur von einer Tabelle in eine andere Tabelle kopiert, gruppiert, erweitert (Bsp.: mit technischen IDs), etc. werden. Hier würde ich immer eine etwas komplexere Verarbeitung in der Datenbank als in einem darüber liegendem Layer bevorzugen.

Aber auch aus der Historie der Anwendung heraus können komplexe Datenbankverarbeitungen existieren. Hier lohnen sich Datenbanktest ganz besonders. Man kann so nicht nur seine Weiterentwicklung absichern, sondern auch eher ein Migration und Überarbeitung angehen. Wer weiß schon ohne Tests ob der neue Code zum gleichen Ergebnis führt?

Referenzanwendung

Als Basis für meine Erläuterungen habe ich mich für eine relativ einfache Verarbeitung entschieden. Mein .NET DataAcessLayer ruft eine Stored Procedure im MS SQL Server auf. Dabei sollen Daten aus der Tabelle [dbo].[Source] in die Tabellen [dbo].[Target_Code] und [dbo].[Target_Sum] überführt werden. Sie werden nach [Code] gruppiert und mit ein technischer Schlüssel über [dbo].[Target_Code] versehen, der ggf. auch neu erzeugt werden muss. Die Summen pro Code Schlüssel und Datum werden in [dbo].[Target_Sum] gespeichert.

Die später zu testende Datenbank:

CREATE PROCEDURE [dbo].[Delete_Target_Sum_ByCalcDate] 
    @CalcDate AS DATETIME
AS
BEGIN
    SET NOCOUNT ON;
  
    DELETE FROM dbo.Target_Sum WHERE CalcDate = @CalcDate;
END

CREATE PROCEDURE [dbo].[Insert_Target_ByCalcDate] 
    @CalcDate AS DATETIME
AS
BEGIN
    SET NOCOUNT ON;
  
    WITH Source_Code AS
    (
        SELECT 
            DISTINCT Code
        FROM dbo.Source
        WHERE CalcDate = @CalcDate
    )
    INSERT INTO dbo.Target_Code
    (
        Code
    )
    SELECT 
        Code
    FROM Source_Code
    WHERE Code not in (SELECT Code FROM dbo.Target_Code);
  
    WITH Source_Sum AS
    (
        SELECT 
            Code,
            SUM(ISNULL(Value,0.0)) as Value_Sum
        FROM dbo.Source
        WHERE CalcDate = @CalcDate
        GROUP BY Code
    )
    INSERT INTO dbo.Target_Sum 
    ( 
        CalcDate,
        ID,
        Value
    )
    SELECT 
        @CalcDate, 
        C.ID, 
        S.Value_Sum
    FROM Source_Sum AS S
    INNER JOIN dbo.Target_Code C
    ON S.Code = C.Code;
  
  
END

und ihre Zugriffsschicht

public class DBManagerTarget
{
public void DeleteTargetSum(DateTime calcDate)
{
    ExecSql((SqlCommand cmd) => FillCommand(cmd, "dbo.Delete_Target_Sum_ByCalcDate", calcDate));
}
  
public void FillTarget(DateTime calcDate)
{
    ExecSql((SqlCommand cmd) => FillCommand(cmd, "dbo.Insert_Target_ByCalcDate", calcDate));
}
  
private void FillCommand(SqlCommand cmd, string spName, DateTime calcDate)
{
    cmd.CommandType = System.Data.CommandType.StoredProcedure;
    cmd.CommandText = spName;
  
    SqlParameter parCalcDate = cmd.CreateParameter();
    parCalcDate.ParameterName = "@CalcDate";
    parCalcDate.DbType = System.Data.DbType.DateTime;
    parCalcDate.SqlValue = calcDate.Date.ToString("yyyy-MM-dd HH:mm:ss");
    cmd.Parameters.Add(parCalcDate);
}
  
public void ExecSql(Action<SqlCommand> fillCommand)
{
    try
    {
        string connectionString = ConfigurationManager.ConnectionStrings["DB"].ConnectionString;
        using (SqlConnection con = new SqlConnection(connectionString))
        {
            con.Open();
            using (SqlCommand cmd = con.CreateCommand())
            {
                fillCommand(cmd);
                cmd.ExecuteNonQuery();
            }
        }
    }
    catch (Exception ex)
    {
        //TODO
        throw;
    }
}
}

Testhilfen

Was wäre ein Test ohne eine entsprechende Prüfung? Um mir hier das Leben zu vereinfachen habe ich diese Prüfung in ein eigenes Assembly ausgelagert. Dazu gehören:

Dateien mit SQL Befehlen im Test gegen die Datenbank ausführen
Speichern von Ergebnissen eines SQL Befehls in einer Datei
Einfacher Dateienvergleich.

public class DBManager
{
    public string ConnectionStringKey { get; private set; }
    public bool AssertTransactionContext { get; private set; }
  
    public DBManager(string connectionStringKey, bool assertTransactionContext)
    {
        ConnectionStringKey = connectionStringKey;
        AssertTransactionContext = assertTransactionContext;
    }
  
    public void ExecFile(string filePath)
    {
        string sql = File.ReadAllText(filePath);
        ExecCommand(sql);
    }
  
    public void ExecCommand(string cmdText)
    {
        try
        {
            string connectionString = ConfigurationManager.ConnectionStrings[ConnectionStringKey].ConnectionString;
            using (SqlConnection con = new SqlConnection(connectionString))
            {
                if (AssertTransactionContext && Transaction.Current == null)
                    throw new ArgumentException("nicht ohne Transaction!");
  
                con.Open();
                //con.EnlistTransaction(transaction);
                /* alternative für GO
                        Server db = new Server(new ServerConnection(conn));
                        string script = File.ReadAllText(scriptPath);
                        db.ConnectionContext.ExecuteNonQuery(script); 
                */
  
                foreach (string cmd in cmdText.Split(new string[] { "GO" }, StringSplitOptions.RemoveEmptyEntries))
                {
                    using (SqlCommand sqlCmd = new SqlCommand())
                    {
                        sqlCmd.Connection = con;
  
  
                        sqlCmd.CommandType = System.Data.CommandType.Text;
                        sqlCmd.CommandText = cmd;
  
                        sqlCmd.ExecuteNonQuery();
                    }
                }
  
  
                con.Close();
            }
        }
        catch (Exception ex)
        {
            //TODO
            throw;
        }
    }
        
    public void ReadToFile(string filePath, string cmdText)
    {
        try
        {
            string connectionString = ConfigurationManager.ConnectionStrings[ConnectionStringKey].ConnectionString;
            using (SqlConnection con = new SqlConnection(connectionString))
            {
                if (AssertTransactionContext && Transaction.Current == null)
                    throw new ArgumentException("nicht ohne Transaction!");
  
                con.Open();
                using (SqlCommand sqlCmd = new SqlCommand())
                {
                    sqlCmd.Connection = con;
  
  
                    sqlCmd.CommandType = System.Data.CommandType.Text;
                    sqlCmd.CommandText = cmdText;
  
                    using (SqlDataReader reader = sqlCmd.ExecuteReader())
                    {
                        File.Delete(filePath); //könnte auch Folder mit Timestamp erzeugen!
                        using (FileStream stream = new FileStream(filePath, FileMode.CreateNew))
                        {
                            using (StreamWriter writer = new StreamWriter(stream, Encoding.UTF8))
                            {
                                writer.WriteLine(cmdText);
                                writer.WriteLine("");
                                writer.WriteLine(GetColumnInfo(reader));
                                writer.WriteLine("");
  
                                while (reader.Read())
                                {
                                    writer.WriteLine(GetData(reader));
                                }
                            }
                        }
                    }
                }
  
                con.Close();
            }
        }
        catch (Exception ex)
        {
            //TODO
            throw;
        }
    }
  
    private string GetColumnInfo(SqlDataReader reader)
    {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < reader.FieldCount; i++)
        {                
            if(i > 0)
                sb.Append(",");
  
            sb.AppendFormat("{0}({1})", reader.GetName(i), reader.GetDataTypeName(i));
        }
  
        return sb.ToString();
    }
  
    private string GetData(SqlDataReader reader)
    {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < reader.FieldCount; i++)
        {
            if (i > 0)
                sb.Append(",");
  
            sb.AppendFormat("{0}", reader.GetValue(i));
        }
  
        return sb.ToString();
    }
}

public static class CompareHelper
{
    public static void AssertAreEual(string expectedFilePath, string actualFilePath)
    {
        string expectedContent = File.ReadAllText(expectedFilePath,Encoding.UTF8);
        string actualContent = File.ReadAllText(actualFilePath, Encoding.UTF8);
        Assert.AreEqual(expectedContent, actualContent);
    }
}

Testfall

Die Tabelle [dbo].[Source] enthält folgende Daten:

Nach dem Test sollen die Tabelle [dbo].[Target_Code] wie folgt befüllt sein:

und die Tabelle [dbo].[Target_Sum] so:

Im Test werden das SQL-Statement, die Spaltenstruktur und das Ergebnis in eine Textdatei geschrieben und verglichen. Der erwartete Inhalt der Datei sieht wie folgt aus:

SELECT * FROM dbo.Target_Sum WHERE CalcDate='2014-01-01';
 
CalcDate(datetime),ID(int),Value(float)
 
01.01.2014 00:00:00,1,10
01.01.2014 00:00:00,2,20
01.01.2014 00:00:00,3,30
01.01.2014 00:00:00,4,40

Diese Umgebung wird meine Grundlage sein, um die verschiedenen Vorgehen zu vergleichen. Während Daten, Anwendung und sogar Prüfung der Test gleich bleiben, wird sich lediglich die Methodik und das Konzept der Test ändern.

zur Übersicht