In-Memory-SQLite-Datenbank kopieren, um Unit-Tests schneller zu machen

Question

In C#/nHibernate-Projekten verwende ich SQLite, um meinen Code zu testen, ungefähr mit der hier beschriebenen Methode: http://ayende.com/blog/3983/nhibernate-unit-testing.

Ich finde jedoch, dass das Erstellen und Konfigurieren der In-Memory-Datenbank in der Regel etwa 150 ms dauert. Ich habe viele Komponententests, also addiert sich das schnell.

Ich möchte die Datenbank einmal erstellen und konfigurieren, sie in einer statischen Variablen speichern und jedes Mal kopieren, wenn ein Komponententest eine Datenbank benötigt.

Wie kann ich eine In-Memory-Datenbank sichern?

Ich habe zuerst versucht, eine benannte In-Memory-Datenbank zu erstellen. Dies ist gemäß https://www.sqlite.org/inmemorydb.html möglich. Früher habe ich haben:

private const string ConnectionString = "Data Source=:memory:;Version=3;"; 

Verbindungszeichenfolgen Ich habe versucht, sind:

private const string ConnectionString = "FullUri=file:memorydb.db?mode=memory&cache=shared"; 
    private const string ConnectionString2 = "FullUri=file:memorydb2.db?mode=memory&cache=shared"; 

So, jetzt muss ich nur noch herausfinden, wie schnell Inhalte von einem zum anderen kopieren zu? Ich bin fast da: Ich kann zwei In-Memory-Datenbanken erstellen und "BackupDatabase" aufrufen, um die Datenbank zu kopieren.

Der Komponententest verhält sich jedoch wie die "Instanz" -Datenbank hat keine Tabellen, sogar die "Prototyp" -Datenbank.

Answer 1

Ich landete mit dieser Arbeitscode. Die Testdauer meines Tests ging von über zehn Minuten auf unter zwei Minuten. (-Code leicht zur besseren Lesbarkeit vereinfacht)

using System; 
using System.Data; 
using System.Data.SQLite; 
using System.IO; 
using System.Reflection; 
using FluentNHibernate.Cfg; 
using FluentNHibernate.Cfg.Db; 
using NHibernate; 
using NHibernate.Mapping; 
using NHibernate.Tool.hbm2ddl; 

namespace TestHelper.DbHelper.SqLite 
{ 
    public class DatabaseScope : IDisposable 
    { 
     private static Assembly _prototypeAssembly; 
     private const string PrototypeConnectionString = "FullUri=file:prototype.db?mode=memory&cache=shared"; 
     private static ISessionFactory _prototypeSessionFactory; 
     private static SQLiteConnection _prototypeConnection; 

     private const string InstanceConnectionString = "FullUri=file:instance.db?mode=memory&cache=shared"; 
     private ISessionFactory _instanceSessionFactory; 
     private SQLiteConnection _instanceConnection; 

     public DatabaseScope(Assembly assembly) 
     { 
      InitDatabasePrototype(assembly); 
      InitDatabaseInstance(); 
     } 

     private void InitDatabasePrototype(Assembly assembly) 
     { 
      if (_prototypeAssembly == assembly) return; 

      if (_prototypeConnection != null) 
      { 
       _prototypeConnection.Close(); 
       _prototypeConnection.Dispose(); 
       _prototypeSessionFactory.Dispose(); 
      } 

      _prototypeAssembly = assembly; 

      _prototypeConnection = new SQLiteConnection(PrototypeConnectionString); 
      _prototypeConnection.Open(); 

      _prototypeSessionFactory = Fluently 
       .Configure() 
       .Database(SQLiteConfiguration.Standard.ConnectionString(PrototypeConnectionString)) 
       .Mappings(m => m.HbmMappings.AddFromAssembly(assembly)) 
       .ExposeConfiguration(cfg => new SchemaExport(cfg).Execute(false, true, false, _prototypeConnection, null)) 
       .BuildSessionFactory(); 
     } 

     private void InitDatabaseInstance() 
     { 
      _instanceSessionFactory = Fluently 
       .Configure() 
       .Database(SQLiteConfiguration.Standard.ConnectionString(InstanceConnectionString)) 
       .Mappings(m => m.HbmMappings.AddFromAssembly(_prototypeAssembly)) 
       .BuildSessionFactory(); 

      _instanceConnection = new SQLiteConnection(InstanceConnectionString); 
      _instanceConnection.Open(); 

      _prototypeConnection.BackupDatabase(_instanceConnection, "main", "main", -1, null, -1); 
     } 

     public ISession OpenSession() 
     { 
      return _instanceSessionFactory.OpenSession(_instanceConnection); 
     } 

     public void Dispose() 
     { 
      _instanceConnection.Close(); 
      _instanceConnection.Dispose(); 
      _instanceSessionFactory.Dispose(); 
     } 
    } 
} 

Answer 2

Was ich mit SQLite in Speicherdatenbanken beobachtet habe, ist, dass, sobald Sie die Verbindung schließen, alles in der Datenbank verschwunden ist. So tun, was Sie wollen,

1. Erstellen Sitzung Fabrik für die Backup-Datenbank, offene Session und bauen Schema nicht über diese Sitzung schließen, bis Sie Ihre gesamte Testsuite beenden

2. Sitzung Fabrik erstellen für Ihre Zieldatenbank, offene Sitzung und verwendet, um die Verbindung von diesem Sitzungsobjekt und die Verbindung von Sitzung aus Schritt 1 erstellten Daten

3. verwenden sie die Sitzung auf Schritt 2 für Test erstellt zu kopieren und schließen, sobald Test beendet ist

Ein andere Lösung ist die einzige Sitzung zu verwenden, um mehrere Tests (alle Tests in einzelner Testvorrichtung) ausführen, dann müssen Sie keine neue Sitzung Fabrik pro Test schaffen, aber pro TestFixture