/// <summary>
/// Assets that the specified SQL LocalDB instance name is in the specified state of existence.
/// </summary>
/// <param name="instanceName">The instance name to assert for.</param>
/// <param name="exists">Whether the specified instance name is expected to exist.</param>
private static void AssertExistence(string instanceName, bool exists)
{
ISqlLocalDbInstanceInfo info = SqlLocalDbApi.GetInstanceInfo(instanceName);
Assert.IsNotNull(info, "SqlLocalDbApi.GetInstanceInfo() returned null.");
Assert.AreEqual(exists, info.Exists, "ISqlLocalDbInstanceInfo.Exists is incorrect.");
}
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 void SqlLocalDbProvider_CreateInstance_Creates_Instance()
{
// Arrange
Helpers.EnsureLocalDBInstalled();
SqlLocalDbProvider target = new SqlLocalDbProvider();
// Act
SqlLocalDbInstance result = target.CreateInstance();
// Assert
Assert.IsNotNull(result, "CreateInstance() returned null.");
Assert.IsNotNull(result.Name, "SqlLocalDbInstance.Name is null.");
try
{
ISqlLocalDbInstanceInfo info = result.GetInstanceInfo();
Assert.IsNotNull(info, "GetInstanceInfo() returned null.");
Assert.IsTrue(info.Exists, "ISqlLocalDbInstanceInfo.Exists is incorrect.");
Assert.IsFalse(info.IsRunning, "ISqlLocalDbInstanceInfo.IsRunning is incorrect.");
Assert.AreEqual(
new Version(target.Version).Major,
info.LocalDbVersion.Major,
"ISqlLocalDbInstanceInfo.LocalDbVersion is incorrect.");
Assert.IsTrue(Guid.TryParse(result.Name, out Guid unused), "SqlLocalDbInstance.Name is not a valid GUID.");
}
finally
{
SqlLocalDbInstance.Delete(result);
}
}
public void SqlLocalDbProvider_CreateInstance_Creates_Instance_With_Specified_Name()
{
// Arrange
Helpers.EnsureLocalDBInstalled();
SqlLocalDbProvider target = new SqlLocalDbProvider();
string instanceName = Guid.NewGuid().ToString();
// Act
SqlLocalDbInstance result = target.CreateInstance(instanceName);
// Assert
Assert.IsNotNull(result, "CreateInstance() returned null.");
Assert.AreEqual(instanceName, result.Name, "SqlLocalDbInstance.Name is incorrect.");
try
{
ISqlLocalDbInstanceInfo info = result.GetInstanceInfo();
Assert.IsNotNull(info, "GetInstanceInfo() returned null.");
Assert.IsTrue(info.Exists, "ISqlLocalDbInstanceInfo.Exists is incorrect.");
Assert.IsFalse(info.IsRunning, "ISqlLocalDbInstanceInfo.IsRunning is incorrect.");
Assert.AreEqual(
new Version(target.Version).Major,
info.LocalDbVersion.Major,
"ISqlLocalDbInstanceInfo.LocalDbVersion is incorrect.");
}
finally
{
SqlLocalDbInstance.Delete(result);
}
}
public void SqlLocalDbProvider_As_ISqlLocalDbFactory_GetInstance_Returns_Specified_Instance()
{
// Arrange
Helpers.EnsureLocalDBInstalled();
ISqlLocalDbProvider target = new SqlLocalDbProvider();
string instanceName = Guid.NewGuid().ToString();
// Act
SqlLocalDbApi.CreateInstance(instanceName);
try
{
// Assert
ISqlLocalDbInstance result = target.GetInstance(instanceName);
Assert.IsNotNull(result, "CreateInstance() returned null.");
Assert.AreEqual(instanceName, result.Name, "SqlLocalDbInstance.Name is incorrect.");
ISqlLocalDbInstanceInfo info = result.GetInstanceInfo();
Assert.IsTrue(info.Exists, "ISqlLocalDbInstanceInfo.Exists is incorrect.");
Assert.IsFalse(info.IsRunning, "ISqlLocalDbInstanceInfo.IsRunning is incorrect.");
Assert.IsTrue(Guid.TryParse(result.Name, out Guid unused), "SqlLocalDbInstance.Name is not a valid GUID.");
}
finally
{
SqlLocalDbApi.DeleteInstance(instanceName);
}
}
public void SqlLocalDbInstance_Delete_Deletes_Instance()
{
// Arrange
Helpers.EnsureLocalDBInstalled();
string instanceName = Guid.NewGuid().ToString();
SqlLocalDbApi.CreateInstance(instanceName);
Mock <ISqlLocalDbInstance> mock = new Mock <ISqlLocalDbInstance>();
mock.Setup((p) => p.Name).Returns(instanceName);
ISqlLocalDbInstanceInfo info = SqlLocalDbApi.GetInstanceInfo(instanceName);
Assert.IsNotNull(info, "SqlLocalDbApi.GetInstanceInfo() returned null.");
Assert.IsTrue(info.Exists, "ISqlLocalDbInstanceInfo.Exists is incorrect.");
ISqlLocalDbInstance instance = mock.Object;
// Act
SqlLocalDbInstance.Delete(instance);
// Assert
info = SqlLocalDbApi.GetInstanceInfo(instanceName);
Assert.IsNotNull(info, "SqlLocalDbApi.GetInstanceInfo() returned null.");
Assert.IsFalse(info.Exists, "The SQL LocalDB instance was not deleted.");
string path = Path.Combine(SqlLocalDbApi.GetInstancesFolderPath(), instanceName);
Assert.IsTrue(Directory.Exists(path), "The instance folder was deleted.");
Assert.AreNotEqual(0, Directory.GetFiles(path).Length, "The instance files were deleted.");
}
public void SqlLocalDbInstance_Delete_If_SqlLocalDbApi_AutomaticallyDeleteInstanceFiles_Is_True()
{
// Arrange
Helpers.EnsureLocalDBInstalled();
Helpers.InvokeInNewAppDomain(
() =>
{
SqlLocalDbApi.AutomaticallyDeleteInstanceFiles = true;
string instanceName = Guid.NewGuid().ToString();
SqlLocalDbApi.CreateInstance(instanceName);
Mock <ISqlLocalDbInstance> mock = new Mock <ISqlLocalDbInstance>();
mock.Setup((p) => p.Name).Returns(instanceName);
ISqlLocalDbInstanceInfo info = SqlLocalDbApi.GetInstanceInfo(instanceName);
Assert.IsNotNull(info, "SqlLocalDbApi.GetInstanceInfo() returned null.");
Assert.IsTrue(info.Exists, "ISqlLocalDbInstanceInfo.Exists is incorrect.");
ISqlLocalDbInstance instance = mock.Object;
// Act
SqlLocalDbInstance.Delete(instance);
// Assert
info = SqlLocalDbApi.GetInstanceInfo(instanceName);
Assert.IsNotNull(info, "SqlLocalDbApi.GetInstanceInfo() returned null.");
Assert.IsFalse(info.Exists, "The SQL LocalDB instance was not deleted.");
string path = Path.Combine(SqlLocalDbApi.GetInstancesFolderPath(), instanceName);
Assert.IsFalse(Directory.Exists(path), "The instance folder was not deleted.");
});
}
private static void AddTodoContext(IServiceProvider serviceProvider, DbContextOptionsBuilder options)
{
// Check that SQL Server LocalDB is installed
ISqlLocalDbApi localDB = serviceProvider.GetRequiredService <ISqlLocalDbApi>();
if (!localDB.IsLocalDBInstalled())
{
throw new NotSupportedException("SQL LocalDB is not installed.");
}
// Get the configured SQL LocalDB instance to store the TODO items in, creating it if it does not exist
IConfiguration config = serviceProvider.GetRequiredService <IConfiguration>();
ISqlLocalDbInstanceInfo instance = localDB.GetOrCreateInstance(config["SqlLocalDbInstance"]);
// Ensure that the SQL LocalDB instance is running and start it if not already running
if (!instance.IsRunning)
{
instance.Manage().Start();
}
// Get the SQL connection string to use to connect to the LocalDB instance
string connectionString = instance.GetConnectionString();
options.UseSqlServer(connectionString);
}
/// <summary>
/// Initializes a new instance of the <see cref="SqlLocalDbInstance"/> class.
/// </summary>
/// <param name="instanceName">The name of the SQL Server LocalDB instance.</param>
/// <param name="localDB">The <see cref="ISqlLocalDbApi"/> instance to use.</param>
/// <exception cref="ArgumentNullException">
/// <paramref name="instanceName"/> is <see langword="null"/>.
/// </exception>
/// <exception cref="InvalidOperationException">
/// The LocalDB instance specified by <paramref name="instanceName"/> does not exist.
/// </exception>
/// <exception cref="SqlLocalDbException">
/// The LocalDB instance specified by <paramref name="instanceName"/> could not be obtained.
/// </exception>
internal SqlLocalDbInstance(string instanceName, ISqlLocalDbApi localDB)
{
if (instanceName == null)
{
throw new ArgumentNullException(nameof(instanceName));
}
Debug.Assert(localDB != null, "localDB cannot be null.");
ISqlLocalDbInstanceInfo info = localDB.GetInstanceInfo(instanceName);
if (info == null || !info.Exists)
{
string message = SRHelper.Format(
SR.SqlLocalDbInstance_InstanceNotFoundFormat,
instanceName);
Logger.Error(Logger.TraceEvent.General, message);
throw new InvalidOperationException(message);
}
_instanceName = instanceName;
_namedPipe = info.NamedPipe;
}
public void Can_Get_Instances_From_Names()
{
// Arrange
using (var api = new SqlLocalDbApi(_loggerFactory))
{
IReadOnlyList <string> names = api.GetInstanceNames();
foreach (string name in names)
{
// Act
ISqlLocalDbInstanceInfo info = api.GetInstanceInfo(name);
// Assert
info.ShouldNotBeNull();
}
// Arrange
string instanceName = Guid.NewGuid().ToString();
// Act
bool actual = api.InstanceExists(instanceName);
// Assert
actual.ShouldBeFalse();
}
}
public static void Share_Throws_If_SqlLocalDbEception_Is_Thrown()
{
// Act
var innerException = new SqlLocalDbException(
"It broke",
123,
"Name");
var mock = new Mock <ISqlLocalDbApi>();
mock.Setup((p) => p.ShareInstance(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Throws(innerException);
ISqlLocalDbInstanceInfo instance = CreateInstance();
ISqlLocalDbApi api = mock.Object;
var target = new SqlLocalDbInstanceManager(instance, api);
var exception = Assert.Throws <SqlLocalDbException>(() => target.Share("SharedName"));
exception.ErrorCode.ShouldBe(123);
exception.InstanceName.ShouldBe("Name");
exception.Message.ShouldBe("Failed to share SQL LocalDB instance 'Name'.");
exception.InnerException.ShouldBeSameAs(innerException);
}
public void Can_Create_SqlLocalDB_Instances_With_Different_Versions()
{
// Arrange
using (var actual = new SqlLocalDbApi(_loggerFactory))
{
foreach (string version in actual.Versions)
{
// Act
ISqlLocalDbVersionInfo versionInfo = actual.GetVersionInfo(version);
// Assert
versionInfo.ShouldNotBeNull();
versionInfo.Name.ShouldStartWith(version.Split('.').First());
versionInfo.Exists.ShouldBeTrue();
versionInfo.Version.ShouldNotBeNull();
versionInfo.Version.ShouldNotBe(new Version());
string instanceName = Guid.NewGuid().ToString();
// Act
ISqlLocalDbInstanceInfo instanceInfo = actual.CreateInstance(instanceName, version);
// Assert
instanceInfo.ShouldNotBeNull();
instanceInfo.Name.ShouldBe(instanceName);
instanceInfo.Exists.ShouldBeTrue();
instanceInfo.IsRunning.ShouldBeFalse();
instanceInfo.LocalDbVersion.ShouldBe(versionInfo.Version);
// Act (no Assert)
actual.DeleteInstance(instanceName);
actual.DeleteInstanceFiles(instanceName);
}
}
}
public SqlLocalDb()
{
_localDb = new SqlLocalDbApi();
_instance = _localDb.GetOrCreateInstance("SSS-LoadTests");
_manager = _instance.Manage();
Initialize().Wait();
}
public static void CreateConnectionStringBuilder_Throws_If_Instance_Is_Null()
{
// Arrange
ISqlLocalDbInstanceInfo instance = null;
// Act and Assert
Assert.Throws <ArgumentNullException>("instance", () => instance.CreateConnectionStringBuilder());
}
public void Dispose()
{
this.sqlLocalDbApi?.Dispose();
this.sqlLocalDbApi = null;
this.dbInstance = null;
this.manager = null;
}
public static void Manage_Throws_If_Instance_Is_Null()
{
// Arrange
ISqlLocalDbInstanceInfo instance = null;
// Act and Assert
Assert.Throws <ArgumentNullException>("instance", () => instance.Manage());
}
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");
}
public void Share_Throws_If_SharedName_Is_Null()
{
// Act
ISqlLocalDbInstanceInfo instance = CreateInstance();
var api = Mock.Of <ISqlLocalDbApi>();
var target = new SqlLocalDbInstanceManager(instance, api);
Assert.Throws <ArgumentNullException>("sharedName", () => target.Share(null !));
}
public static string GetRunningConnectionString(ISqlLocalDbInstanceInfo db)
{
if (!db.IsRunning)
{
db.Manage().Start();
}
return(db.GetConnectionString());
}
public void Constructor_Validates_Arguments()
{
// Act
ISqlLocalDbInstanceInfo instance = CreateInstance();
var api = Mock.Of <ISqlLocalDbApi>();
// Act and Assert
Assert.Throws <ArgumentNullException>("instance", () => new SqlLocalDbInstanceManager(null !, api));
Assert.Throws <ArgumentNullException>("api", () => new SqlLocalDbInstanceManager(instance, null !));
}
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 void TemporarySqlLocalDbInstance_GetInstanceInfo_Returns_ISqlLocalDbInstanceInfo()
{
// Arrange
using (TemporarySqlLocalDbInstance target = TemporarySqlLocalDbInstance.Create())
{
// Act
ISqlLocalDbInstanceInfo result = target.GetInstanceInfo();
// Assert
Assert.IsNotNull(result, "GetInstanceInfo() returned null.");
}
}
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 Constructor_Initializes_Properties()
{
// Act
ISqlLocalDbInstanceInfo instance = CreateInstance();
var api = Mock.Of <ISqlLocalDbApi>();
// Act
var actual = new SqlLocalDbInstanceManager(instance, api);
// Assert
actual.Name.ShouldBe("Name");
actual.NamedPipe.ShouldBe("NamedPipe");
}
public void GetDefaultInstance_Returns_The_Default_Instance()
{
// Arrange
using var api = new SqlLocalDbApi(_loggerFactory);
// Act
ISqlLocalDbInstanceInfo actual = api.GetDefaultInstance();
// Assert
actual.ShouldNotBeNull();
actual.IsAutomatic.ShouldBeTrue();
actual.Name.ShouldBe(api.DefaultInstanceName);
}
public static IServiceCollection AddSqlLocalDbInstance(this IServiceCollection services, Action <TOptions> setupAction = null)
{
if (setupAction != null)
{
services.Configure(setupAction);
}
services.AddSingleton <ISqlLocalDbInstanceInfo>(provider =>
{
var options = provider.GetService <IOptions <TOptions> >() ?? new OptionsWrapper <TOptions>(provider.GetRequiredService <TOptions>());
ISqlLocalDbApi localDB = provider.GetRequiredService <ISqlLocalDbApi>();
if (!localDB.IsLocalDBInstalled())
{
throw new NotSupportedException("SQL LocalDB is not installed.");
}
// Get the configured SQL LocalDB instance to store the TODO items in, creating it if it does not exist
ISqlLocalDbInstanceInfo instance = localDB.GetOrCreateInstance(options?.Value?.InstanceName ?? "SqlLocalDb-DefaultDb");
// Ensure that the SQL LocalDB instance is running and start it if not already running
if (!instance.IsRunning)
{
instance.Manage().Start();
}
// Get the SQL connection string to use to connect to the LocalDB instance
//string connectionString = instance.GetConnectionString();
return(instance);
});
services.AddSingleton <Server>(provider =>
{
var options = provider.GetService <IOptions <TOptions> >() ?? new OptionsWrapper <TOptions>(provider.GetRequiredService <TOptions>());
var instance = provider.GetRequiredService <ISqlLocalDbInstanceInfo>();
string connString = instance.GetConnectionString();
//var conn = new SqlConnection(connString);
var builder = instance.CreateConnectionStringBuilder();
builder.InitialCatalog = options?.Value.DatabaseName ?? "";
var conn = new SqlConnection(builder.ConnectionString);
var server = new Server(new ServerConnection(conn));
return(server);
});
return(services);
}
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 Dispose()
{
try
{
this.manager.Stop();
}
catch { }
this.sqlLocalDbApi?.Dispose();
this.sqlLocalDbApi = null;
this.dbInstance = null;
this.manager = null;
}
public void Unshare_Unshares_Instance()
{
// Act
var mock = new Mock <ISqlLocalDbApi>();
ISqlLocalDbInstanceInfo instance = CreateInstance();
ISqlLocalDbApi api = mock.Object;
var target = new SqlLocalDbInstanceManager(instance, api);
// Act
target.Unshare();
// Assert
mock.Verify((p) => p.UnshareInstance("Name"), Times.Once());
}
