Copia il database SQLite in memoria per rendere più veloci i test di unità

Question

In C#/nHibernate-projects Sto usando SQLite per testare il mio codice, utilizzando approssimativamente il metodo descritto qui: http://ayende.com/blog/3983/nhibernate-unit-testing.

Tuttavia, trovo che la creazione e la configurazione del database in memoria richiede in genere circa 150 ms. Ho un sacco di test unitario quindi questo si aggiunge rapidamente.

Voglio costruire e configurare il database una volta, memorizzarlo in una variabile statica e copiarlo ogni volta che un test di unità richiede un database.

Come eseguire il backup di un database in memoria?

Prima ho provato a creare un database in memoria denominato. Secondo https://www.sqlite.org/inmemorydb.html questo è possibile. Ho usato per avere:

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

stringhe di connessione che ho provato sono:

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

Così ora non mi resta che scoprire come copiare rapidamente i contenuti da uno all'altro? Sono quasi arrivato: posso creare due database in memoria e chiamare "BackupDatabase" per copiare il database.

Il test di unità, tuttavia, si comporta come se il database di "istanza" non avesse tabelle, anche il database "prototipo".

 private static ISessionFactory _prototypeSessionFactory; 
     private const string InstanceConnectionString = "FullUri=file:memorydb.db?mode=memory&cache=shared"; 

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

     public DatabaseScope(Assembly assembly) 
     { 
      var prototyeConfiguration = SQLiteConfiguration.Standard.ConnectionString(PrototypeConnectionString); 
      var cfg = Fluently 
       .Configure() 
       .Database(prototyeConfiguration) 
       .Mappings(m => m.HbmMappings.AddFromAssembly(assembly)); 
      cfg.ExposeConfiguration(BuildSchema); 
      _prototypeSessionFactory = cfg.BuildSessionFactory(); 

      var instanceConfiguration = SQLiteConfiguration.Standard.ConnectionString(InstanceConnectionString); 
      _instanceSessionFactory = Fluently 
       .Configure() 
       .Database(instanceConfiguration) 
       .BuildSessionFactory(); 

      CopyDatabase(); 
     } 

     private void CopyDatabase() 
     { 
      var cnnIn = new SQLiteConnection(PrototypeConnectionString); 
      var cnnOut = new SQLiteConnection(InstanceConnectionString); 
      cnnIn.Open(); 
      cnnOut.Open(); 
      cnnIn.BackupDatabase(cnnOut, "main", "main", -1, null, -1); 
      cnnIn.Close(); 
      cnnOut.Close(); 
     } 

Answer 1

ho finito con questo codice funzionante. La durata del test dell'unità è passata da oltre dieci minuti a meno di due minuti. (Codice leggermente semplificata per migliorare la leggibilità)

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

Quello che ho osservato con SQLite in-memory database è che, non appena si chiude il collegamento, tutto nel db è andato. Quindi, per fare quello che vuoi,

1. Creare fabbrica di sessione per il database di backup, sessione aperta e costruire lo schema non chiudere questa sessione fino al termine della suite di test dell'intero

2. Creare fabbrica di sessione per la vostra database di destinazione, sessione aperta e utilizzare la connessione da questo oggetto di sessione e la connessione dalla sessione creata dal passaggio 1 per copiare i dati

3. utilizzare la sessione creata nel passaggio 2 per la prova e chiudere una volta la prova è finita

Un'altra soluzione è quella di utilizzare la singola sessione di eseguire più test (tutti i test in un'unica apparecchiatura di prova), allora non c'è bisogno di creare una nuova fabbrica di sessione per test, ma per TestFixture