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."); Guid guid; Assert.IsTrue(Guid.TryParse(result.Name, out guid), "SqlLocalDbInstance.Name is not a valid GUID."); } 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 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")); }
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 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 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 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_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); } }
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 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); } }
private void Initialize(string instanceName, string databaseName) { this.databaseName = databaseName; this.instanceName = instanceName; var existing = SqlLocalDbApi.GetInstanceInfo(instanceName); if (existing.Exists) { if (existing.IsRunning) { SqlLocalDbApi.StopInstance(instanceName); } SqlLocalDbApi.DeleteInstance(instanceName); } ISqlLocalDbProvider provider = new SqlLocalDbProvider(); this.instance = provider.GetOrCreateInstance(instanceName); instance.Start(); var connectionStringBuilder = instance.CreateConnectionStringBuilder(); using (var conn = new SqlConnection(connectionStringBuilder.ConnectionString)) { var serverConnection = new ServerConnection(conn); // By default, LocalDB stores database files in the user's home folder. Messy for temporary test databases. // Store them in the user's temp folder instead. var testDatabasesDirectory = Path.Combine(Path.GetTempPath(), "TestDatabases"); if (!Directory.Exists(testDatabasesDirectory)) { Directory.CreateDirectory(testDatabasesDirectory); } // Generate a unique name for our mdf file to avoid clashing with other ongoing test runs. var databaseFileNameRoot = string.Format("{0}_{1}_{2}", databaseName, DateTime.Now.ToString("yyyyMMdd_HHmmss"), Guid.NewGuid().ToString("N")); var mdfFileName = databaseFileNameRoot + ".mdf"; var ldfFileName = databaseFileNameRoot + "_log.ldf"; this.mdfFilePath = Path.Combine(testDatabasesDirectory, mdfFileName); this.ldfFilePath = Path.Combine(testDatabasesDirectory, ldfFileName); var sql = string.Format("CREATE DATABASE {0} ON (NAME = N'{0}', FILENAME = '{1}')", databaseName, this.mdfFilePath); Console.WriteLine(string.Format("Creating database {0} at {1}", databaseName, this.mdfFilePath)); serverConnection.ExecuteNonQuery(sql); } connectionStringBuilder.InitialCatalog = this.databaseName; this.connectionString = connectionStringBuilder.ConnectionString; }
public void Delete() { if (!Exists) { return; } SqlLocalDbApi.StopInstance(_databaseName); SqlLocalDbApi.DeleteInstance(_databaseName, true); }
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 DelInstance_Click(object sender, EventArgs e) { string nameInstance = ((Button)sender).Parent.Name; DialogResult answer = MessageBox.Show("Вы действительно хотите удалить данный экзмепляр?", $"Удаление {nameInstance}", MessageBoxButtons.YesNo); if (answer == DialogResult.Yes) { WaitLabel(); SqlLocalDbApi.DeleteInstance(nameInstance, true); RefreshInstances(); } }
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 }
private SqlLocalDbInstance GetExistingInstance(SqlLocalDbProvider localDbProvider, string localDbInstanceName) { try { SqlLocalDbInstance existingInstance = localDbProvider.GetInstance(localDbInstanceName); IEnumerable <string> filePaths = GetPhysicalFilesForServer(existingInstance); bool isMissingFiles = filePaths.Any(path => !File.Exists(path)); // If at least one file doesn't exist, delete them all. // We have found that the SqlLocalDbInstanceInfo.Exists property to not be reliable. if (isMissingFiles) { LogAction("Existing LocalDb instance with name " + localDbInstanceName + " was found but some physical files were missing"); LogAction("Deleting instance and will attempt to recreate"); existingInstance.Stop(); SqlLocalDbApi.DeleteInstance(existingInstance.Name, deleteFiles: true); foreach (string filePath in filePaths) { try { File.Delete(filePath); } catch (DirectoryNotFoundException) { } } return(null); } else { LogAction("Found existing LocalDb instance with name " + localDbInstanceName + " and will use it"); LogAction("If you would like to delete this existing instance and let DbTestMonkey create a new instance run the following commands at a command line"); LogAction(" sqllocaldb stop " + localDbInstanceName); LogAction(" sqllocaldb delete " + localDbInstanceName); return(existingInstance); } } catch (InvalidOperationException) { LogAction("Existing LocalDb instance with name " + localDbInstanceName + " was not found"); } return(null); }
/// <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_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); } }
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); } }
/// <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); }
public void SqlLocalDbProvider_GetInstances_Returns_Installed_Instances() { // Arrange Helpers.EnsureLocalDBInstalled(); SqlLocalDbProvider target = new SqlLocalDbProvider(); // Act IList <ISqlLocalDbInstanceInfo> result = target.GetInstances(); int initialCount = result.Count; // Assert Assert.IsNotNull(result, "GetInstances() returned null."); Assert.IsTrue(result.Count > 0, "No instances were returned by GetInstances()."); CollectionAssert.AllItemsAreNotNull(result.ToList(), "GetInstances() returned a null instance."); string instanceName = Guid.NewGuid().ToString(); target.CreateInstance(instanceName); try { result = target.GetInstances(); // Assert Assert.IsNotNull(result, "GetInstances() returned null."); Assert.AreEqual(initialCount + 1, result.Count, "An incorrect number instances were returned by GetInstances()."); CollectionAssert.AllItemsAreNotNull(result.ToList(), "GetInstances() returned a null instance."); Assert.IsTrue(result.Where((p) => p.Name == instanceName).Any(), "The new instance was not returned in the created set of instances."); } finally { SqlLocalDbApi.DeleteInstance(instanceName); } result = target.GetInstances(); // Assert Assert.IsNotNull(result, "GetInstances() returned null."); Assert.AreEqual(initialCount, result.Count, "An incorrect number instances were returned by GetInstances()."); CollectionAssert.AllItemsAreNotNull(result.ToList(), "GetInstances() returned a null instance."); }
/// <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); }
private void CleanupLocalDbDatabase() { SqlLocalDbApi.AutomaticallyDeleteInstanceFiles = true; SqlLocalDbApi.StopOptions = StopInstanceOptions.KillProcess; var localDbProvider = new SqlLocalDbProvider(); var localDbInstanceInfo = localDbProvider.GetInstances().FirstOrDefault(instance => instance.Name == DatabaseName); if (localDbInstanceInfo != null) { var localDbInstance = localDbProvider.GetInstance(DatabaseName); if (!localDbInstance.IsRunning) { localDbInstance.Start(); } this.CleanupMsSqlDatabase(localDbInstance.CreateConnectionStringBuilder().ConnectionString); SqlLocalDbApi.StopInstance(DatabaseName, TimeSpan.FromSeconds(20.0)); SqlLocalDbApi.DeleteInstance(DatabaseName); } }
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 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 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); } }