public void Use_With_Dependency_Injection()
{
// Register with SQL LocalDB services
var services = new ServiceCollection()
.AddLogging((builder) => builder.AddXUnit(OutputHelper))
.AddSqlLocalDB();
IServiceProvider serviceProvider = services.BuildServiceProvider();
using (IServiceScope scope = serviceProvider.CreateScope())
{
ISqlLocalDbApi localDB = scope.ServiceProvider.GetService <ISqlLocalDbApi>();
ISqlLocalDbInstanceInfo instance = localDB.GetDefaultInstance();
ISqlLocalDbInstanceManager manager = instance.Manage();
if (!instance.IsRunning)
{
manager.Start();
}
using (SqlConnection connection = instance.CreateConnection())
{
connection.Open();
// Use the SQL connection...
}
}
}
public SqlLocalDb()
{
_localDb = new SqlLocalDbApi();
_instance = _localDb.GetOrCreateInstance("SSS-LoadTests");
_manager = _instance.Manage();
Initialize().Wait();
}
public async Task CreateConnection_Creates_A_Sql_Connection()
{
// Arrange
using (var api = new SqlLocalDbApi(_loggerFactory))
{
using (TemporarySqlLocalDbInstance temporary = api.CreateTemporaryInstance(deleteFiles: true))
{
ISqlLocalDbInstanceManager manager = temporary.Manage();
manager.ShouldNotBeNull();
manager.Name.ShouldBe(temporary.Name);
// Act
using (SqlConnection actual = manager.CreateConnection())
{
// Assert
actual.ShouldNotBeNull();
actual.ConnectionString.ShouldNotBeNull();
actual.State.ShouldBe(ConnectionState.Closed);
await actual.OpenAsync();
actual.Close();
}
}
}
}
public void CreateConnection_Throws_If_Manager_Is_Null()
{
// Arrange
ISqlLocalDbInstanceManager manager = null;
// Act and Assert
Assert.Throws <ArgumentNullException>("manager", () => manager.CreateConnection());
}
public void Restart_Throws_If_Manager_Is_Null()
{
// Arrange
ISqlLocalDbInstanceManager manager = null;
// Act and Assert
Assert.Throws <ArgumentNullException>("manager", () => manager.Restart());
}
public void Dispose()
{
this.sqlLocalDbApi?.Dispose();
this.sqlLocalDbApi = null;
this.dbInstance = null;
this.manager = null;
}
public DacpacDbFixture()
{
Console.WriteLine("Running fixture constructor...");
_localDb = new SqlLocalDbApi();
DateTime nowUtc = DateTime.UtcNow;
LocalDbInstanceName = $"{nowUtc.ToString("yyyyMMddHHmmssFFFFFFF")}"; //something mostly unique
_instance = _localDb.GetOrCreateInstance(LocalDbInstanceName);
_manager = _instance.Manage();
if (!_instance.IsRunning)
{
_manager.Start();
}
var packagePath = "SimpleDb.dacpac";
var deployOptions = new DacDeployOptions
{
CreateNewDatabase = true,
GenerateSmartDefaults = true,
};
deployOptions.SqlCommandVariableValues["LoginName"] = DatabaseUserName;
deployOptions.SqlCommandVariableValues["Password"] = DatabasePassword;
SqlConnectionStringBuilder csb = new SqlConnectionStringBuilder();
csb.DataSource = _manager.NamedPipe;
csb.IntegratedSecurity = true;
var databaseName = "SimpleDbUnitTest";
var debugConnectionString = csb.ConnectionString;
var dacServices = new DacServices(debugConnectionString);
using (var package = DacPackage.Load(packagePath))
{
dacServices.Deploy(package, databaseName, true, deployOptions);
}
csb.InitialCatalog = databaseName;
//csb.UserID = DatabaseUserName;
//csb.Password = DatabasePassword;
//csb.IntegratedSecurity = false;
ConnectionString = csb.ConnectionString;
EntityConnectionStringBuilder ecsb = new EntityConnectionStringBuilder();
string nameOfConnectionString = "SimpleDbModel"; //NOTE: HACK: this must match the name of my Entity Framework model (the .edmx guy)
string providerName = "System.Data.SqlClient";
ecsb.Provider = providerName;
ecsb.ProviderConnectionString = csb.ConnectionString;
ecsb.Metadata = $"res://*/{nameOfConnectionString}.csdl|res://*/{nameOfConnectionString}.ssdl|res://*/{nameOfConnectionString}.msl";
EfConnectionString = ecsb.ConnectionString;
NumberOfTimesDacpacWasApplied++;
Debug.WriteLine($">> The DACPAC has been applied {NumberOfTimesDacpacWasApplied} times");
Console.WriteLine($">> The DACPAC has been applied {NumberOfTimesDacpacWasApplied} times");
}
/// <summary>
/// Creates a connection to the LocalDB instance.
/// </summary>
/// <param name="manager">The <see cref="ISqlLocalDbInstanceManager"/> associated with the instance to create a connection to.</param>
/// <returns>
/// An instance of <see cref="SqlConnection"/> that can be used to connect to the LocalDB instance.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="manager"/> is <see langword="null"/>.
/// </exception>
public static SqlConnection CreateConnection(this ISqlLocalDbInstanceManager manager)
{
if (manager == null)
{
throw new ArgumentNullException(nameof(manager));
}
return(manager.GetInstanceInfo().CreateConnection());
}
/// <summary>
/// Restarts the specified <see cref="ISqlLocalDbInstanceManager"/> instance.
/// </summary>
/// <param name="manager">The <see cref="ISqlLocalDbInstanceManager"/> associated with the instance to restart.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="manager"/> is <see langword="null"/>.
/// </exception>
public static void Restart(this ISqlLocalDbInstanceManager manager)
{
if (manager == null)
{
throw new ArgumentNullException(nameof(manager));
}
manager.Stop();
manager.Start();
}
private void StartLocalDbInstance()
{
bool creating = !this.localDbApi.InstanceExists(dbInstanceName);
this.logger.LogTrace($"{(creating ? "Creating" : "Connecting to")} internal DB instance {dbInstanceName}");
this.localDbInstance = this.localDbApi.CreateInstance(dbInstanceName);
this.instanceManager = this.localDbInstance.Manage();
if (!this.localDbInstance.IsRunning)
{
this.logger.LogTrace($"Starting internal DB instance {dbInstanceName}");
this.instanceManager.Start();
}
var bbuilder = this.localDbInstance.CreateConnectionStringBuilder();
bbuilder.InitialCatalog = "master";
bbuilder.ConnectTimeout = 30;
bbuilder.IntegratedSecurity = true;
this.masterDbConnectionString = bbuilder.ToString();
this.logger.LogTrace($"Master DB connection string {this.masterDbConnectionString}");
if (creating)
{
this.EnableContainment();
}
if (!this.IsDbAttached())
{
if (File.Exists(this.localDbPath))
{
this.logger.LogTrace($"Attaching existing DB {this.localDbPath} to instance");
this.AttachExistingDb();
}
else
{
this.logger.LogTrace($"Creating new DB {this.localDbPath} in instance");
this.CreateDb();
}
}
else
{
this.logger.LogTrace($"Database was already attached to instance {dbInstanceName}");
}
bbuilder = this.localDbInstance.CreateConnectionStringBuilder();
bbuilder.InitialCatalog = "AccessManager";
bbuilder.ConnectTimeout = 30;
bbuilder.IntegratedSecurity = true;
this.ConnectionString = bbuilder.ToString();
this.logger.LogTrace($"AccessManager DB connection string {this.ConnectionString}");
}
public DatabaseFixture()
{
this.localDB = new SqlLocalDbApi();
instance = localDB.GetOrCreateInstance(DatabaseFixture.LOCALDB_NAME);
manager = instance.Manage();
if (!instance.IsRunning)
{
manager.Start();
}
RestoreBackup().GetAwaiter().GetResult();
}
public SqlServer()
{
this.sqlLocalDbApi = new SqlLocalDbApi();
this.dbInstance = this.sqlLocalDbApi.GetDefaultInstance();
this.manager = this.dbInstance.Manage();
if (!this.dbInstance.IsRunning)
{
Normal("SqlServer: Start");
this.manager.Start();
}
}
public void Restart_Stops_And_Starts_Instance()
{
// Arrange
using var api = new SqlLocalDbApi(_loggerFactory);
using TemporarySqlLocalDbInstance temporary = api.CreateTemporaryInstance(deleteFiles: true);
ISqlLocalDbInstanceManager manager = temporary.Manage();
// Act
manager.Restart();
// Assert
temporary.GetInstanceInfo().IsRunning.ShouldBeTrue();
}
public void Dispose()
{
try
{
this.manager.Stop();
}
catch { }
this.sqlLocalDbApi?.Dispose();
this.sqlLocalDbApi = null;
this.dbInstance = null;
this.manager = null;
}
private static string InitSqlLocalDB()
{
ISqlLocalDbApi localDB = new SqlLocalDbApi();
ISqlLocalDbInstanceInfo instance = localDB.GetOrCreateInstance(@"localtestdb");
ISqlLocalDbInstanceManager manager = instance.Manage();
if (!instance.IsRunning)
{
manager.Start();
}
return(instance.GetConnectionString());
}
public void Create_A_Sql_LocalDB_Instance()
{
using (var localDB = new SqlLocalDbApi(OutputHelper.ToLoggerFactory()))
{
ISqlLocalDbInstanceInfo instance = localDB.GetOrCreateInstance("MyInstance");
ISqlLocalDbInstanceManager manager = instance.Manage();
if (!instance.IsRunning)
{
manager.Start();
}
using (SqlConnection connection = instance.CreateConnection())
{
connection.Open();
// Use the SQL connection...
}
manager.Stop();
}
}
public static void Manage_Returns_An_ISqlLocalDbInstanceManager()
{
// Arrange
var api = Mock.Of <ISqlLocalDbApi>();
var mock = new Mock <ISqlLocalDbInstanceInfo>();
mock.As <ISqlLocalDbApiAdapter>()
.Setup((p) => p.LocalDb).Returns(api);
ISqlLocalDbInstanceInfo instance = mock.Object;
// Act
ISqlLocalDbInstanceManager actual = instance.Manage();
// Assert
actual.ShouldNotBeNull();
var adapter = actual as ISqlLocalDbApiAdapter;
adapter.ShouldNotBeNull();
adapter.LocalDb.ShouldBeSameAs(api);
}
public static void RegisterAndPopulateLocalDatabase(this IServiceCollection services)
{
var options = new SqlLocalDbOptions()
{
AutomaticallyDeleteInstanceFiles = true,
StopOptions = StopInstanceOptions.NoWait,
StopTimeout = TimeSpan.FromDays(1),
};
services.AddSingleton(sp => new SqlLocalDbApi(options, sp.GetRequiredService <ILoggerFactory>()));
services.AddSingleton(sp =>
{
ISqlLocalDbInstanceInfo instance = sp.GetRequiredService <SqlLocalDbApi>().GetOrCreateInstance("ProductSuggestions");
if (!instance.IsRunning)
{
ISqlLocalDbInstanceManager manager = instance.Manage();
manager.Start();
}
sp.GetRequiredService <ILogger <ISqlLocalDbInstanceInfo> >().LogInformation($"\nConnectionString:\n{instance.GetConnectionString()}");
var upgrader = DeployChanges.To
.SqlDatabase(instance.GetConnectionString())
.WithScriptsEmbeddedInAssembly(Assembly.GetExecutingAssembly())
.LogToConsole()
.Build();
var result = upgrader.PerformUpgrade();
if (!result.Successful)
{
throw result.Error;
}
return(instance);
});
}
