private void CreateLocalDb() { string connection = System.Configuration.ConfigurationManager.ConnectionStrings["BVCareManager.Properties.Settings.BVCareManagerConnectionString"].ConnectionString; string localDbstring = @"(LocalDB)\"; int pFrom = connection.IndexOf(localDbstring) + localDbstring.Length; int pTo = connection.LastIndexOf(";AttachDbFilename"); string resultLocalDb = connection.Substring(pFrom, pTo - pFrom); #region SqlLocalDb Handle var localDb = new SqlLocalDbApi(); ISqlLocalDbInstanceInfo localDbInstance = localDb.GetInstanceInfo(resultLocalDb); string localDbVersion = localDbInstance.LocalDbVersion.ToString().Substring(0, 2); if (localDbVersion == "0.") { try { localDb.CreateInstance(resultLocalDb, "12.0"); } catch { MessageBox.Show("Phiên bản SQL Server LocalDB hiện tại không phù hợp. Hãy cài đặt phiên bản 12.0 (SQL Server 2014 Express LocalDb)"); Environment.Exit(1); } } else if (localDbVersion != "0." && localDbVersion != "12") { localDb.StopInstance(resultLocalDb); localDb.DeleteInstance(resultLocalDb); try { localDb.CreateInstance(resultLocalDb, "12.0"); } catch { MessageBox.Show("Phiên bản SQL Server LocalDB hiện tại không phù hợp. Hãy cài đặt phiên bản 12.0 (SQL Server 2014 Express LocalDb)"); Environment.Exit(1); } } localDb.StartInstance(resultLocalDb); #endregion }
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_Share_Throws_If_SharedName_Is_Null() { // Arrange Helpers.EnsureLocalDBInstalled(); string instanceName = Guid.NewGuid().ToString(); SqlLocalDbApi.CreateInstance(instanceName); try { SqlLocalDbInstance target = new SqlLocalDbInstance(instanceName); string sharedName = null; // Act and Assert throw ErrorAssert.Throws <ArgumentNullException>( () => target.Share(sharedName), "sharedName"); } finally { SqlLocalDbApi.DeleteInstance(instanceName); } }
public void SqlLocalDbInstance_CreateConnectionStringBuilder_If_Instance_Started() { // Arrange Helpers.EnsureLocalDBInstalled(); string instanceName = Guid.NewGuid().ToString(); SqlLocalDbApi.CreateInstance(instanceName); try { SqlLocalDbInstance target = new SqlLocalDbInstance(instanceName); target.Start(); try { // Act SqlConnectionStringBuilder result = target.CreateConnectionStringBuilder(); // Assert Assert.IsNotNull(result, "CreateConnection() returned null."); StringAssert.Contains(result.ConnectionString, target.NamedPipe, "SqlConnection.ConnectionString is incorrect."); } finally { SqlLocalDbApi.StopInstance(instanceName); } } finally { SqlLocalDbApi.DeleteInstance(instanceName); } }
public void SqlLocalDbInstance_Share_Throws_If_SharedName_Is_Invalid() { // Arrange Helpers.EnsureLocalDBInstalled(); string instanceName = Guid.NewGuid().ToString(); string sharedName = "\\\\"; SqlLocalDbApi.CreateInstance(instanceName); try { SqlLocalDbInstance target = new SqlLocalDbInstance(instanceName); // Act SqlLocalDbException error = ErrorAssert.Throws <SqlLocalDbException>( () => target.Share(sharedName)); // Assert Assert.AreEqual(SqlLocalDbErrors.InvalidInstanceName, error.ErrorCode, "SqlLocalDbException.ErrorCode is incorrect."); Assert.AreEqual(instanceName, error.InstanceName, "SqlLocalDbException.InstanceName is incorrect."); throw error; } finally { SqlLocalDbApi.DeleteInstance(instanceName); } }
public void SqlLocalDbInstance_Stop_Throws_If_An_Error_Occurs() { // Arrange Helpers.EnsureLocalDBInstalled(); string instanceName = Guid.NewGuid().ToString(); SqlLocalDbApi.CreateInstance(instanceName); SqlLocalDbInstance target; try { target = new SqlLocalDbInstance(instanceName); } finally { SqlLocalDbApi.DeleteInstance(instanceName); } // Act SqlLocalDbException error = ErrorAssert.Throws <SqlLocalDbException>( () => target.Stop()); // Assert Assert.AreEqual(SqlLocalDbErrors.UnknownInstance, error.ErrorCode, "SqlLocalDbException.ErrorCode is incorrect."); Assert.AreEqual(instanceName, error.InstanceName, "SqlLocalDbException.InstanceName is incorrect."); throw error; }
public void Can_Delete_User_Instances() { // Arrange using (var actual = new SqlLocalDbApi(_loggerFactory)) { actual.CreateInstance(Guid.NewGuid().ToString()); IReadOnlyList <string> namesBefore = actual.GetInstanceNames(); // Act int deleted = actual.DeleteUserInstances(deleteFiles: true); // Assert deleted.ShouldBeGreaterThanOrEqualTo(1); IReadOnlyList <string> namesAfter = actual.GetInstanceNames(); int instancesDeleted = 0; foreach (string name in namesBefore) { if (!namesAfter.Contains(name)) { instancesDeleted++; } } instancesDeleted.ShouldBeGreaterThanOrEqualTo(1); } }
public void SqlLocalDbInstance_Constructor_If_Instance_Is_Started() { // Arrange Helpers.EnsureLocalDBInstalled(); string instanceName = Guid.NewGuid().ToString(); try { SqlLocalDbApi.CreateInstance(instanceName); try { string namedPipe = SqlLocalDbApi.StartInstance(instanceName); // Act SqlLocalDbInstance target = new SqlLocalDbInstance(instanceName); // Assert Assert.IsTrue(target.IsRunning, "SqlLocalDbInstance.IsRunning is incorrect."); Assert.AreEqual(instanceName, target.Name, "SqlLocalDbInstance.Name is incorrect."); Assert.AreEqual(namedPipe, target.NamedPipe, "SqlLocalDbInstance.NamedPipe is incorrect."); } finally { SqlLocalDbApi.StopInstance(instanceName); } } finally { SqlLocalDbApi.DeleteInstance(instanceName); } }
public void TemporarySqlLocalDbInstance_Dispose_Does_Not_Throw_If_Instance_Cannot_Be_Stopped_Due_To_Sql_LocalDb_Error() { // Arrange string instanceName = "MyTempInstance" + Guid.NewGuid().ToString(); var mock = new Mock <SqlLocalDbProvider>() { CallBase = true, }; // Set up the CreateInstance() method to create an SQL LocalDB // instance but that then throws an exception when stopped. mock.Setup((p) => p.CreateInstance(instanceName)) .Returns( () => { SqlLocalDbApi.CreateInstance(instanceName); return(new SqlLocalDbInstanceThatCannotBeStopped(instanceName)); }) .Verifiable(); ISqlLocalDbProvider provider = mock.Object; // Act using (TemporarySqlLocalDbInstance target = new TemporarySqlLocalDbInstance(instanceName, provider)) { } // Assert mock.Verify(); // Tidy up as the stop intentionally failed, meaning delete would also have failed SqlLocalDbApi.StopInstance(instanceName); SqlLocalDbApi.DeleteInstance(instanceName); }
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 Throws_PlatformNotSupportedException() { // Arrange using (var actual = new SqlLocalDbApi(_loggerFactory)) { // Act and Assert Assert.Throws <PlatformNotSupportedException>(() => actual.CreateInstance("name")); Assert.Throws <PlatformNotSupportedException>(() => actual.DeleteInstance("name")); Assert.Throws <PlatformNotSupportedException>(() => actual.DeleteUserInstances()); Assert.Throws <PlatformNotSupportedException>(() => actual.GetDefaultInstance()); Assert.Throws <PlatformNotSupportedException>(() => actual.GetInstanceInfo("name")); Assert.Throws <PlatformNotSupportedException>(() => actual.GetInstanceNames()); Assert.Throws <PlatformNotSupportedException>(() => actual.GetInstances()); Assert.Throws <PlatformNotSupportedException>(() => actual.GetOrCreateInstance("name")); Assert.Throws <PlatformNotSupportedException>(() => actual.GetVersionInfo("name")); Assert.Throws <PlatformNotSupportedException>(() => actual.InstanceExists("name")); Assert.Throws <PlatformNotSupportedException>(() => actual.LatestVersion); Assert.Throws <PlatformNotSupportedException>(() => actual.ShareInstance("name", "sharedName")); Assert.Throws <PlatformNotSupportedException>(() => actual.ShareInstance("sid", "name", "sharedName")); Assert.Throws <PlatformNotSupportedException>(() => actual.StartInstance("name")); Assert.Throws <PlatformNotSupportedException>(() => actual.StartTracing()); Assert.Throws <PlatformNotSupportedException>(() => actual.StopInstance("name")); Assert.Throws <PlatformNotSupportedException>(() => actual.StopTracing()); Assert.Throws <PlatformNotSupportedException>(() => actual.UnshareInstance("name")); } }
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 void Throws_InvalidOperationException_If_SQL_LocalDB_Not_Installed() { // Arrange var options = new SqlLocalDbOptions(); var registry = Mock.Of <Interop.IRegistry>(); using (var actual = new SqlLocalDbApi(options, registry, _loggerFactory)) { // Act and Assert Assert.Throws <InvalidOperationException>(() => actual.CreateInstance("name")); Assert.Throws <InvalidOperationException>(() => actual.DeleteInstance("name")); Assert.Throws <InvalidOperationException>(() => actual.DeleteUserInstances()); Assert.Throws <InvalidOperationException>(() => actual.GetDefaultInstance()); Assert.Throws <InvalidOperationException>(() => actual.GetInstanceInfo("name")); Assert.Throws <InvalidOperationException>(() => actual.GetInstanceNames()); Assert.Throws <InvalidOperationException>(() => actual.GetInstances()); Assert.Throws <InvalidOperationException>(() => actual.GetOrCreateInstance("name")); Assert.Throws <InvalidOperationException>(() => actual.GetVersionInfo("name")); Assert.Throws <InvalidOperationException>(() => actual.InstanceExists("name")); Assert.Throws <InvalidOperationException>(() => actual.LatestVersion); Assert.Throws <InvalidOperationException>(() => actual.ShareInstance("name", "sharedName")); Assert.Throws <InvalidOperationException>(() => actual.StartInstance("name")); Assert.Throws <InvalidOperationException>(() => actual.StartTracing()); Assert.Throws <InvalidOperationException>(() => actual.StopInstance("name")); Assert.Throws <InvalidOperationException>(() => actual.StopTracing()); Assert.Throws <InvalidOperationException>(() => actual.UnshareInstance("name")); } }
private static void Execute() { var localInfo = SqlLocalDbApi.GetInstanceInfo(AppConfig.Database); if (localInfo.Exists) { SqlLocalDbApi.StopInstance(localInfo.Name); SqlLocalDbApi.DeleteInstance(localInfo.Name, true); } SqlLocalDbApi.CreateInstance(localInfo.Name); using (var memoryStream = new MemoryStream()) { var remote = new DacServices(AppConfig.RemoteConnectionString); remote.ProgressChanged += (sender, args) => Console.WriteLine($"remote {args.Status} {args.Message}"); remote.ExportBacpac(memoryStream, localInfo.Name, DacSchemaModelStorageType.Memory); using (var bacPackage = BacPackage.Load(memoryStream, DacSchemaModelStorageType.Memory)) { var local = new DacServices(AppConfig.LocalConnectionString); local.ProgressChanged += (sender, args) => Console.WriteLine($"local {args.Status} {args.Message}"); local.ImportBacpac(bacPackage, localInfo.Name); } } }
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."); }); }
public void SqlLocalDbInstance_CreateConnection_If_Instance_Is_Started_And_Returned_ConnectionStringBuilder_Is_Null() { // Arrange Helpers.EnsureLocalDBInstalled(); string instanceName = Guid.NewGuid().ToString(); SqlLocalDbApi.CreateInstance(instanceName); try { var mock = new Mock <SqlLocalDbInstance>(instanceName) { CallBase = true, }; mock.Setup((p) => p.CreateConnectionStringBuilder()) .Returns(null as SqlConnectionStringBuilder); SqlLocalDbInstance target = mock.Object; target.Start(); try { // Act SqlConnection result = target.CreateConnection(); try { // Assert Assert.IsNotNull(result, "CreateConnection() returned null."); Assert.AreEqual(ConnectionState.Closed, result.State, "SqlConnection.State is incorrect."); Assert.AreEqual(string.Empty, result.ConnectionString, "SqlConnection.ConnectionString is incorrect."); } finally { if (result != null) { result.Dispose(); } } } finally { SqlLocalDbApi.StopInstance(instanceName); } } finally { SqlLocalDbApi.DeleteInstance(instanceName); } }
private void btnAddInstance_Click(object sender, EventArgs e) { if (tbName.Text.Length <= 1) { MessageBox.Show("Слишком короткое имя экземпляра", "Ошибка создания"); tbName.Focus(); return; } WaitLabel(); SqlLocalDbApi.CreateInstance(tbName.Text, cbVersion.Text); tbName.Text = null; RefreshInstances(); }
public void Methods_Validate_Parameters() { // Arrange TimeSpan timeout = TimeSpan.Zero.Add(TimeSpan.FromTicks(-1)); using (var actual = new SqlLocalDbApi(_loggerFactory)) { // Act and Assert Assert.Throws <ArgumentNullException>("instanceName", () => actual.CreateInstance(null, "version")); Assert.Throws <ArgumentNullException>("version", () => actual.CreateInstance("instanceName", null)); Assert.Throws <ArgumentNullException>("instanceName", () => actual.DeleteInstance(null)); Assert.Throws <ArgumentNullException>("instanceName", () => actual.GetInstanceInfo(null)); Assert.Throws <ArgumentNullException>("version", () => actual.GetVersionInfo(null)); Assert.Throws <ArgumentNullException>("ownerSid", () => actual.ShareInstance(null, "instanceName", "sharedInstanceName")); Assert.Throws <ArgumentNullException>("instanceName", () => actual.ShareInstance("ownerSid", null, "sharedInstanceName")); Assert.Throws <ArgumentNullException>("sharedInstanceName", () => actual.ShareInstance("ownerSid", "instanceName", null)); Assert.Throws <ArgumentException>("instanceName", () => actual.ShareInstance("sid", string.Empty, "sharedInstanceName")); Assert.Throws <ArgumentNullException>("instanceName", () => actual.StartInstance(null)); Assert.Throws <ArgumentNullException>("instanceName", () => actual.StopInstance(null, TimeSpan.Zero)); Assert.Throws <ArgumentOutOfRangeException>("timeout", () => actual.StopInstance("instanceName", timeout)).ActualValue.ShouldBe(timeout); Assert.Throws <ArgumentNullException>("instanceName", () => actual.UnshareInstance(null)); } }
public void SqlLocalDbApi_Throws_Exception_For_Native_Errors() { // Arrange string instanceName = new string('$', 10000); using var actual = new SqlLocalDbApi(_loggerFactory); // Act var exception = Assert.Throws <SqlLocalDbException>(() => actual.CreateInstance(instanceName)); // Assert exception.ErrorCode.ShouldBe(SqlLocalDbErrors.InvalidParameter); exception.Message.ShouldStartWith("The parameter for the LocalDB Instance API method is incorrect. Consult the API documentation."); exception.InstanceName.ShouldBe(instanceName); }
/// <summary> /// Create an instance of SQL Server LocalDB /// </summary> /// <param name="instanceName">instance name</param> /// <param name="version">version of SQL Serer LocalDB</param> /// <param name="isRecreate">If an instance of the same name exists, destroy it before creating it</param> public static void CreateInstance(string instanceName, string version, bool isRecreate) { if (SqlLocalDbApi.GetInstanceNames().Contains(instanceName)) { if (isRecreate) { // For details of options, see API Reference : https://msdn.microsoft.com/ja-JP/library/hh234692.aspx SqlLocalDbApi.StopInstance(instanceName, StopInstanceOptions.KillProcess, new TimeSpan(0, 0, 30)); SqlLocalDbApi.DeleteInstance(instanceName, true); } else { return; } } SqlLocalDbApi.CreateInstance(instanceName, version); }
public void SqlLocalDbInstance_Unshare_If_Instance_Is_Started() { // Arrange Helpers.EnsureLocalDBInstalled(); Helpers.EnsureUserIsAdmin(); string instanceName = Guid.NewGuid().ToString(); SqlLocalDbApi.CreateInstance(instanceName); try { SqlLocalDbInstance target = new SqlLocalDbInstance(instanceName); target.Start(); try { string sharedName = Guid.NewGuid().ToString(); target.Share(sharedName); ISqlLocalDbInstanceInfo info = SqlLocalDbApi.GetInstanceInfo(instanceName); Assert.IsNotNull(info, "SqlLocalDbApi.GetInstanceInfo() returned null."); Assert.IsTrue(info.IsShared, "ISqlLocalDbInstanceInfo.IsShared is incorrect."); Assert.AreEqual(sharedName, info.SharedName, "ISqlLocalDbInstanceInfo.SharedName is incorrect."); // Act target.Unshare(); // Assert info = SqlLocalDbApi.GetInstanceInfo(instanceName); Assert.IsNotNull(info, "SqlLocalDbApi.GetInstanceInfo() returned null."); Assert.IsFalse(info.IsShared, "ISqlLocalDbInstanceInfo.IsShared is incorrect."); Assert.AreEqual(string.Empty, info.SharedName, "ISqlLocalDbInstanceInfo.SharedName is incorrect."); } finally { SqlLocalDbApi.StopInstance(instanceName); } } finally { SqlLocalDbApi.DeleteInstance(instanceName); } }
public void Manager_Shares_And_Unshares_Instance() { // Act string instanceName = Guid.NewGuid().ToString(); string sharedName = Guid.NewGuid().ToString(); using (var api = new SqlLocalDbApi(_loggerFactory)) { api.CreateInstance(instanceName); try { api.StartInstance(instanceName); try { var instance = api.GetInstanceInfo(instanceName); var manager = new SqlLocalDbInstanceManager(instance, api); // Act manager.Share(sharedName); // Assert instance.IsShared.ShouldBeTrue(); // Act manager.Unshare(); // Assert instance.IsShared.ShouldBeFalse(); } catch (Exception) { api.StopInstance(instanceName); throw; } } catch (Exception) { api.DeleteInstance(instanceName, deleteFiles: true); throw; } } }
public void SqlLocalDbInstance_CreateConnection_If_Instance_Is_Started() { // Arrange Helpers.EnsureLocalDBInstalled(); string instanceName = Guid.NewGuid().ToString(); SqlLocalDbApi.CreateInstance(instanceName); try { SqlLocalDbInstance target = new SqlLocalDbInstance(instanceName); target.Start(); try { // Act SqlConnection result = target.CreateConnection(); try { // Assert Assert.IsNotNull(result, "CreateConnection() returned null."); Assert.AreEqual(ConnectionState.Closed, result.State, "SqlConnection.State is incorrect."); StringAssert.Contains(result.ConnectionString, target.NamedPipe, "SqlConnection.ConnectionString is incorrect."); } finally { if (result != null) { result.Dispose(); } } } finally { SqlLocalDbApi.StopInstance(instanceName); } } finally { SqlLocalDbApi.DeleteInstance(instanceName); } }
public void SqlLocalDbInstance_Stop_Stops_Instance() { // Arrange Helpers.EnsureLocalDBInstalled(); string instanceName = Guid.NewGuid().ToString(); SqlLocalDbApi.CreateInstance(instanceName); try { SqlLocalDbInstance target = new SqlLocalDbInstance(instanceName); target.Start(); ISqlLocalDbInstanceInfo info = SqlLocalDbApi.GetInstanceInfo(instanceName); Assert.IsNotNull(info, "SqlLocalDbApi.GetInstanceInfo() returned null."); Assert.IsTrue(info.IsRunning, "The SQL LocalDB instance was not started."); Assert.IsTrue(target.IsRunning, "SqlLocalDbInstance.IsRunning is incorrect."); Assert.AreNotEqual(string.Empty, target.NamedPipe, "SqlLocalDbInstance.NamedPipe is incorrect."); // Act target.Stop(); try { // Assert info = SqlLocalDbApi.GetInstanceInfo(instanceName); Assert.IsNotNull(info, "SqlLocalDbApi.GetInstanceInfo() returned null."); Assert.IsFalse(info.IsRunning, "ISqlLocalDbInstanceInfo.IsRunning is incorrect."); Assert.IsFalse(target.IsRunning, "SqlLocalDbInstance.IsRunning is incorrect."); Assert.AreEqual(string.Empty, target.NamedPipe, "SqlLocalDbInstance.NamedPipe is incorrect."); } finally { SqlLocalDbApi.StopInstance(instanceName); } } finally { SqlLocalDbApi.DeleteInstance(instanceName); } }
/// <summary> /// Create an instance of SQL Server LocalDB /// </summary> /// <param name="instanceName">instance name</param> /// <param name="version">version of SQL Serer LocalDB</param> /// <param name="isRecreate">If an instance of the same name exists, destroy it before creating it</param> public static void CreateInstance(string instanceName, string version, bool isRecreate) { var localDb = new SqlLocalDbApi(); if (localDb.GetInstanceNames().Contains(instanceName)) { if (isRecreate) { // For details of options, see API Reference : https://docs.microsoft.com/en-us/sql/relational-databases/express-localdb-instance-apis/sql-server-express-localdb-reference-instance-apis localDb.StopInstance(instanceName, StopInstanceOptions.KillProcess, new TimeSpan(0, 0, 30)); localDb.DeleteInstance(instanceName, true); } else { return; } } localDb.CreateInstance(instanceName, version); }
/// <summary> /// Initializes the database. /// </summary> /// <param name="connection"></param> public static INDbUnitTest Initialize(SqlConnection connection) { if (SqlLocalDbApi.GetInstanceInfo(InstanceName).Exists) { SqlLocalDbApi.StopInstance(InstanceName, TimeSpan.FromSeconds(10)); SqlLocalDbApi.DeleteInstance(InstanceName, true); } SqlLocalDbApi.CreateInstance(InstanceName); var database = new SqlDbUnitTest(connection); database.Scripts.AddSingle($"{TestContext.CurrentContext.TestDirectory}\\Scripts\\InitSchema.sql"); database.Scripts.AddWithWildcard($"{TestContext.CurrentContext.TestDirectory}\\Scripts", "InitTable_*.sql"); database.ExecuteScripts(); database.ReadXmlSchema(Resource.AsStream("Wikibus.xsd")); return(database); }
public void TemporarySqlLocalDbInstance_Constructor_Attempts_To_Delete_Instance_If_Instance_Cannot_Be_Started() { // Arrange string instanceName = "MyTempInstance" + Guid.NewGuid().ToString(); var mock = new Mock <SqlLocalDbProvider>() { CallBase = true, }; // Set up the CreateInstance() method to create an SQL LocalDB // instance but that then throws an exception when started. mock.Setup((p) => p.CreateInstance(instanceName)) .Returns( () => { SqlLocalDbApi.CreateInstance(instanceName); return(new SqlLocalDbInstanceThatCannotBeStarted(instanceName)); }) .Verifiable(); ISqlLocalDbProvider provider = mock.Object; bool deleteFiles = false; // Act InvalidOperationException error = ErrorAssert.Throws <InvalidOperationException>( () => { using (TemporarySqlLocalDbInstance target = new TemporarySqlLocalDbInstance(instanceName, provider, deleteFiles)) { } }); mock.Verify(); ISqlLocalDbInstanceInfo instanceInfo = SqlLocalDbApi.GetInstanceInfo(instanceName); Assert.IsFalse(instanceInfo.Exists, "The temporary instance was not deleted."); throw error; }
public void SqlLocalDbProvider_CreateInstance_Throws_If_Instance_Already_Exists() { // Arrange Helpers.EnsureLocalDBInstalled(); SqlLocalDbProvider target = new SqlLocalDbProvider(); string instanceName = Guid.NewGuid().ToString(); SqlLocalDbApi.CreateInstance(instanceName); try { // Act and Assert throw ErrorAssert.Throws <InvalidOperationException>( () => target.CreateInstance(instanceName)); } finally { SqlLocalDbApi.DeleteInstance(instanceName); } }
public void SqlLocalDbInstance_CreateConnectionStringBuilder_Throws_If_Instance_Not_Started() { // Arrange Helpers.EnsureLocalDBInstalled(); string instanceName = Guid.NewGuid().ToString(); SqlLocalDbApi.CreateInstance(instanceName); try { SqlLocalDbInstance target = new SqlLocalDbInstance(instanceName); // Act and Assert throw ErrorAssert.Throws <InvalidOperationException>( () => target.CreateConnectionStringBuilder()); } finally { SqlLocalDbApi.DeleteInstance(instanceName); } }
public void SqlLocalDbInstance_GetInstanceInfo_Returns_Information_For_The_Specified_Instance() { // Arrange Helpers.EnsureLocalDBInstalled(); string instanceName = Guid.NewGuid().ToString(); SqlLocalDbApi.CreateInstance(instanceName); ISqlLocalDbInstanceInfo expected = SqlLocalDbApi.GetInstanceInfo(instanceName); try { SqlLocalDbInstance target = new SqlLocalDbInstance(instanceName); // Act ISqlLocalDbInstanceInfo result = target.GetInstanceInfo(); // Assert Assert.IsNotNull(result, "GetInstanceInfo() returned null."); Assert.AreEqual(expected.ConfigurationCorrupt, result.ConfigurationCorrupt, "ISqlLocalDbInstanceInfo. is incorrect."); Assert.AreEqual(expected.Exists, result.Exists, "ISqlLocalDbInstanceInfo.Exists is incorrect."); Assert.AreEqual(expected.IsAutomatic, result.IsAutomatic, "ISqlLocalDbInstanceInfo.IsAutomatic is incorrect."); Assert.AreEqual(expected.IsRunning, result.IsRunning, "ISqlLocalDbInstanceInfo.IsRunning is incorrect."); Assert.AreEqual(expected.IsShared, result.IsShared, "ISqlLocalDbInstanceInfo.IsShared is incorrect."); Assert.AreEqual(expected.LastStartTimeUtc, result.LastStartTimeUtc, "ISqlLocalDbInstanceInfo.LastStartTimeUtc is incorrect."); Assert.AreEqual(expected.LocalDbVersion, result.LocalDbVersion, "ISqlLocalDbInstanceInfo.LocalDbVersion is incorrect."); Assert.AreEqual(expected.Name, result.Name, "ISqlLocalDbInstanceInfo.Name is incorrect."); Assert.AreEqual(expected.NamedPipe, result.NamedPipe, "ISqlLocalDbInstanceInfo.NamedPipe is incorrect."); Assert.AreEqual(expected.OwnerSid, result.OwnerSid, "ISqlLocalDbInstanceInfo.OwnerSid is incorrect."); Assert.AreEqual(expected.SharedName, result.SharedName, "ISqlLocalDbInstanceInfo.SharedName is incorrect."); } finally { SqlLocalDbApi.DeleteInstance(instanceName); } }