/// <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()); }