Unit Tests für C # -Code, wo primäre Verarbeitung in SQL Stored Prozeduren auftritt

Ich habe eine Legacy-Anwendung, die umgestaltet und getestet werden sollte. Es besteht aus C # -Code getrennt in model und view Code. Der C # -modelcode stellt im Wesentlichen eine öffentliche API mit hochgradigen CRUD-methods bereit.

In sich ist das C # ziemlich wenig, aber delegiert die eigentliche Arbeit an SQL server gespeicherte Prozeduren. Der C # -Code beschäftigt sich vor allem mit der configuration eines großen Arrays von Parametern, die dann, was in der SQL-database verarbeitet wird, leitet – es gibt sehr wenig Input / Output als solche.

Der Großteil der Verarbeitung erfolgt in diesen gespeicherten Prozeduren. Weil dies Hunderte von Tausenden von databasezeilen ist, scheint es nicht praktisch, das alles in einen ORM-Ansatz umzuwandeln (wo im Wesentlichen die data in den memory in C # geladen werden) – die Verarbeitung sollte wirklich auf dem SQL server bleiben.

Meine Frage ist, wie man etwas testing kann. Die offensichtliche Wahl scheint zu sein:

  • schreibe Unit-Tests für SQL server-Prozeduren
  • schreiben Unit-Tests für den C # -Code (spöttische SQL-Prozeduren)

Dann muss man Integrationstests schreiben, die die Gesamtfunktionalität testing. Da gibt es so wenig functionalität in der C # -Code (einige sind nur Stubs Aufruf der SQL-Proc), hat dies sogar einen Wert im Testen? Es klingt etwas überflüssig für mich.

Es klingt, ich sollte nur Integrationstests machen, die es mir erlauben, bessere Test-Frameworks zu verwenden, als was ich in SQL server machen kann (ich könnte so tun, als ob es sich um Unit-Tests handelt, indem ich mein Wissen über ein SQL-Backend ignoriere) – aber es verletzt das " Einheitsprüfung "Methodik.

Was wäre die praktischste Lösung für dieses Szenario?

Bearbeiten: Die meisten der C # -methods sehen ähnlich wie die unten angegebene Probe aus – manche machen ein paar Zeilen mehr Verarbeitung, aber im Wesentlichen kocht es auf ADO.NET Code:

 public void LogImport (int PeriodID, String orgCode, int userID)
 {
     TryOpenSQLConnection ("ImportSQL.LogImport");

     Versuchen
     {
         SqlCommand cmd = new SqlCommand ("dbo.LogImport", sqlCn);
         cmd.CommandType = CommandType.StoredProcedure;
         cmd.Parameters.AddWithValue ("@ periodID", PeriodID);
         cmd.Parameters.AddWithValue ("@ orgCode", orgCode);
         cmd.Parameters.AddWithValue ("@ userID", userID);
         cmd.ExecuteNonQuery ();
     }
     fangen (exception ex)
     {
         neue DataException ("...")
     }
 }

Ich stimmte zu, dass Sie nur Integrationstests machen sollten. Wenn Ihr C # -Code nicht viel mehr macht als der Umgang mit ADO.net, testing Sie einfach den Anruf zu diesen classn, indem Sie die Hin- und Rückfahrt zum DB machen. Im Idealfall wickeln Sie es alle in einem TransactionScope, so dass Sie es am Ende rollen können:

using (new TransactionScope()) { // integration test }