public void GetNextWorkUnit_ScaffoldingStateModel_ArgumentOutOfRangeException_StateModel(StateModelState state) { // Arrange var drMock = new Mock <IDependencyResolver>(); IWorkUnitFactory wuf = new WorkUnitFactory(drMock.Object); var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); var targetVersion = new Version(1, 0); Task HandlerFunc(bool b) => Task.CompletedTask; var model = new ScaffoldingStateModel(project, configuration, targetVersion, HandlerFunc) { CurrentState = state }; // Act & Assert // ReSharper disable once AssignNullToNotNullAttribute Assert.Throws <ArgumentOutOfRangeException>(() => wuf.GetNextWorkUnit(model)); }
public void Paths_Get_Set() { // Arrange var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); var previousVersion = new Version(1, 0); // ReSharper disable once ConvertToLocalFunction Func <bool, Task> changeHandler = b => Task.CompletedTask; var model = new ScriptCreationStateModel(project, configuration, previousVersion, true, changeHandler); var directories = new DirectoryPaths("projectDirectory", "latestArtifactsDirectory", "newArtifactsDirectory"); var sourcePaths = new DeploySourcePaths("newDacpacPath", "publishProfilePath", "previousDacpacPath"); var targetPaths = new DeployTargetPaths("deployScriptPath", "deployReportPath"); var paths = new PathCollection(directories, sourcePaths, targetPaths); // Act model.Paths = paths; // Assert Assert.AreSame(paths, model.Paths); }
public async Task Work_ScriptCreationStateModel_PersistReportError_Async() { // Arrange var testException = new Exception("test exception"); var daMock = new Mock <IDacAccess>(); daMock.Setup(m => m.CreateDeployFilesAsync("previousDacpacPath", "newDacpacPath", "publishProfilePath", true, true)) .ReturnsAsync(new CreateDeployFilesResult("pre script post", "report", "pre ", " post", new PublishProfile())); var fsaMock = new Mock <IFileSystemAccess>(); fsaMock.Setup(m => m.WriteFileAsync("deployReportPath", "report")) .ThrowsAsync(testException); var loggerMock = new Mock <ILogger>(); IWorkUnit <ScriptCreationStateModel> unit = new CreateDeploymentFilesUnit(daMock.Object, fsaMock.Object, loggerMock.Object); var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); configuration.CreateDocumentationWithScriptCreation = true; var previousVersion = new Version(1, 0); Task HandlerFunc(bool b) => Task.CompletedTask; var directories = new DirectoryPaths("projectDirectory", "latestArtifactsDirectory", "newArtifactsDirectory"); var sourcePaths = new DeploySourcePaths("newDacpacPath", "publishProfilePath", "previousDacpacPath"); var targetPaths = new DeployTargetPaths("deployScriptPath", "deployReportPath"); var paths = new PathCollection(directories, sourcePaths, targetPaths); var model = new ScriptCreationStateModel(project, configuration, previousVersion, false, HandlerFunc) { Paths = paths }; // Act await unit.Work(model, CancellationToken.None); // Assert Assert.AreEqual(StateModelState.TriedToCreateDeploymentFiles, model.CurrentState); Assert.IsFalse(model.Result); fsaMock.Verify(m => m.WriteFileAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Exactly(2)); loggerMock.Verify(m => m.LogErrorAsync("Script creation aborted."), Times.Once); loggerMock.Verify(m => m.LogErrorAsync(testException, "Failed to write deploy report"), Times.Once); }
public async Task GetConfigurationOrDefaultAsync_SqlProject_ConfigurationFound_Async() { // Arrange var fsaMock = new Mock <IFileSystemAccess>(); fsaMock.Setup(m => m.CheckIfFileExists("C:\\Temp\\Test\\Properties\\ssdtlifecycle.json")) .Returns(true); fsaMock.Setup(m => m.ReadFileAsync("C:\\Temp\\Test\\Properties\\ssdtlifecycle.json")) .ReturnsAsync(() => "{ \"ArtifactsPath\": \"__Deployment\", \"PublishProfilePath\": \"Test.publish.xml\", " + "\"SharedDacpacRepositoryPath\": \"C:\\\\Temp\\\\Repository\\\\\", " + "\"BuildBeforeScriptCreation\": false, \"CreateDocumentationWithScriptCreation\": true, " + "\"CommentOutUnnamedDefaultConstraintDrops\": true, \"RemoveSqlCmdStatements\": true, " + "\"ReplaceUnnamedDefaultConstraintDrops\": true, \"VersionPattern\": \"{MAJOR}.0.{BUILD}\", " + "\"TrackDacpacVersion\": true, \"CustomHeader\": \"header\", \"CustomFooter\": \"footer\"}"); var vsaMock = Mock.Of <IVisualStudioAccess>(); var loggerMock = Mock.Of <ILogger>(); IConfigurationService service = new ConfigurationService(fsaMock.Object, vsaMock, loggerMock); var project = new SqlProject("", "C:\\Temp\\Test\\Test.sqlproj", ""); var defaultConfiguration = ConfigurationModel.GetDefault(); // Act var configuration = await service.GetConfigurationOrDefaultAsync(project); // Assert Assert.IsNotNull(configuration); Assert.IsFalse(defaultConfiguration.Equals(configuration)); Assert.AreEqual("__Deployment", configuration.ArtifactsPath); Assert.AreEqual("Test.publish.xml", configuration.PublishProfilePath); Assert.AreEqual("C:\\Temp\\Repository\\", configuration.SharedDacpacRepositoryPath); Assert.IsFalse(configuration.BuildBeforeScriptCreation); Assert.IsTrue(configuration.CreateDocumentationWithScriptCreation); Assert.IsTrue(configuration.CommentOutUnnamedDefaultConstraintDrops); // This must be true to cause an validation error for the last assert. Assert.IsTrue(configuration.ReplaceUnnamedDefaultConstraintDrops); // This must be true to cause an validation error for the last assert. Assert.AreEqual("{MAJOR}.0.{BUILD}", configuration.VersionPattern); Assert.IsTrue(configuration.TrackDacpacVersion); Assert.AreEqual("header", configuration.CustomHeader); Assert.AreEqual("footer", configuration.CustomFooter); Assert.IsTrue(configuration.RemoveSqlCmdStatements); Assert.IsTrue(configuration.HasErrors); // This will check if ValidateAll is called correctly. }
public async Task DoWorkAsync_ExceptionInWorkUnitWithExceptionInCatch_Async() { // Arrange var testException = new Exception("test exception"); var loggerMock = new Mock <ILogger>(); loggerMock.Setup(m => m.LogErrorAsync(testException, "operation failed.")) .ThrowsAsync(new Exception("catch exception")); var wuMock = new Mock <IWorkUnit <ScaffoldingStateModel> >(); var instance = new AsyncExecutorBaseTestImplementation(loggerMock.Object, () => wuMock.Object); var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); var targetVersion = new Version(1, 0); var stateList = new List <bool>(); Task HandlerFunc(bool b) { stateList.Add(b); return(Task.CompletedTask); } var model = new ScaffoldingStateModel(project, configuration, targetVersion, HandlerFunc); var cts = new CancellationTokenSource(); wuMock.Setup(m => m.Work(model, cts.Token)) .ThrowsAsync(testException); // Act await instance.CallDoWorkAsync(model, cts.Token); // Assert Assert.IsNull(model.Result); Assert.AreEqual(2, stateList.Count); Assert.IsTrue(stateList[0]); Assert.IsFalse(stateList[1]); wuMock.Verify(m => m.Work(model, cts.Token), Times.Once); loggerMock.Verify(m => m.LogInfoAsync("started"), Times.Once); loggerMock.Verify(m => m.LogInfoAsync("Creation was canceled by the user."), Times.Never); loggerMock.Verify(m => m.LogInfoAsync(It.Is <string>(s => s.StartsWith("completed stateModel in"))), Times.Never); loggerMock.Verify(m => m.LogErrorAsync(testException, "operation failed."), Times.Once); }
public async Task Work_ScriptCreationStateModel_NoError_Async() { // Arrange var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); configuration.SharedDacpacRepositoryPath = "C:\\Temp\\Test\\"; var previousVersion = new Version(1, 2, 3); Task HandleWorkInProgressChanged(bool arg) => Task.CompletedTask; var directories = new DirectoryPaths("projectDirectory", "latestArtifactsDirectory", "newArtifactsDirectory"); var sourcePaths = new DeploySourcePaths("newDacpacPath", "publishProfilePath", "previousDacpacPath"); var targetPaths = new DeployTargetPaths("deployScriptPath", "deployReportPath"); var paths = new PathCollection(directories, sourcePaths, targetPaths); var model = new ScriptCreationStateModel(project, configuration, previousVersion, true, HandleWorkInProgressChanged) { Paths = paths }; var fsaMock = new Mock <IFileSystemAccess>(); fsaMock.Setup(m => m.EnsureDirectoryExists("C:\\Temp\\Test\\")) .Returns(null as string); fsaMock.Setup(m => m.CopyFile("newDacpacPath", "C:\\Temp\\Test\\newDacpacPath")) .Returns(null as string); var loggerMock = new Mock <ILogger>(); IWorkUnit <ScriptCreationStateModel> unit = new CopyDacpacToSharedDacpacRepositoryUnit(fsaMock.Object, loggerMock.Object); // Act await unit.Work(model, CancellationToken.None); // Assert Assert.AreEqual(StateModelState.TriedToCopyDacpacToSharedDacpacRepository, model.CurrentState); Assert.IsNull(model.Result); fsaMock.Verify(m => m.EnsureDirectoryExists("C:\\Temp\\Test\\"), Times.Once); fsaMock.Verify(m => m.CopyFile("newDacpacPath", "C:\\Temp\\Test\\newDacpacPath"), Times.Once); loggerMock.Verify(m => m.LogInfoAsync("Copying DACPAC to shared DACPAC repository ..."), Times.Once); loggerMock.Verify(m => m.LogErrorAsync(It.IsAny <string>()), Times.Never); loggerMock.Verify(m => m.LogErrorAsync(It.IsAny <Exception>(), It.IsAny <string>()), Times.Never); }
public async Task Work_ScriptCreationStateModel_LoadedSuccessful_Async() { // Arrange var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); var previousVersion = new Version(1, 2, 3); Task HandleWorkInProgressChanged(bool arg) => Task.CompletedTask; var model = new ScriptCreationStateModel(project, configuration, previousVersion, true, HandleWorkInProgressChanged); var spsMock = new Mock <ISqlProjectService>(); spsMock.Setup(m => m.TryLoadSqlProjectPropertiesAsync(project)).ReturnsAsync(true); IWorkUnit <ScriptCreationStateModel> unit = new LoadSqlProjectPropertiesUnit(spsMock.Object); // Act await unit.Work(model, CancellationToken.None); // Assert Assert.AreEqual(StateModelState.SqlProjectPropertiesLoaded, model.CurrentState); Assert.IsNull(model.Result); }
public async Task GetConfigurationOrDefaultAsync_Path_NoConfigurationFound_UseDefault_Async() { // Arrange var exception = new FileNotFoundException("foo"); var fsaMock = new Mock <IFileSystemAccess>(); fsaMock.Setup(m => m.CheckIfFileExists("C:\\Temp\\Test\\Properties\\ssdtlifecycle.json")) .Returns(false); var vsaMock = new Mock <IVisualStudioAccess>(); var loggerMock = new Mock <ILogger>(); IConfigurationService service = new ConfigurationService(fsaMock.Object, vsaMock.Object, loggerMock.Object); var defaultConfiguration = ConfigurationModel.GetDefault(); // Act var configuration = await service.GetConfigurationOrDefaultAsync("C:\\Temp\\Test\\Properties\\ssdtlifecycle.json"); // Assert Assert.IsNotNull(configuration); Assert.IsTrue(defaultConfiguration.Equals(configuration)); vsaMock.Verify(m => m.ShowModalError(It.IsAny <string>()), Times.Never); loggerMock.Verify(m => m.LogErrorAsync(exception, It.IsAny <string>()), Times.Never); }
public async Task Work_ScaffoldingStateModel_LoadFailed_Async() { // Arrange var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); var targetVersion = new Version(1, 2, 3); Task HandleWorkInProgressChanged(bool arg) => Task.CompletedTask; var model = new ScaffoldingStateModel(project, configuration, targetVersion, HandleWorkInProgressChanged); var spsMock = new Mock <ISqlProjectService>(); spsMock.Setup(m => m.TryLoadPathsForScaffoldingAsync(project, configuration)).ReturnsAsync(null as PathCollection); IWorkUnit <ScaffoldingStateModel> unit = new LoadPathsUnit(spsMock.Object); // Act await unit.Work(model, CancellationToken.None); // Assert Assert.AreEqual(StateModelState.PathsLoaded, model.CurrentState); Assert.IsFalse(model.Result); }
public void GetNextWorkUnit_ScaffoldingStateModel_CorrectWorkUnitForTriedToCopyDacpacToSharedDacpacRepository() { // Arrange var drMock = new Mock <IDependencyResolver>(); IWorkUnitFactory wuf = new WorkUnitFactory(drMock.Object); var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); var targetVersion = new Version(1, 0); Task HandlerFunc(bool b) => Task.CompletedTask; var model = new ScaffoldingStateModel(project, configuration, targetVersion, HandlerFunc) { CurrentState = StateModelState.TriedToCopyDacpacToSharedDacpacRepository }; // Act var workUnit = wuf.GetNextWorkUnit(model); // Assert Assert.IsNull(workUnit); }
public async Task Work_ScriptCreationStateModel_CompleteRun_NoFilesDeleted_Async() { // Arrange var fsaMock = new Mock <IFileSystemAccess>(); fsaMock.Setup(m => m.TryToCleanDirectory("p", "*.refactorlog")) .Returns(new string[0]); var vsaMock = new Mock <IVisualStudioAccess>(); var loggerMock = new Mock <ILogger>(); IWorkUnit <ScriptCreationStateModel> unit = new DeleteRefactorLogUnit(fsaMock.Object, vsaMock.Object, loggerMock.Object); var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); configuration.DeleteRefactorlogAfterVersionedScriptGeneration = true; var previousVersion = new Version(1, 0); Task HandlerFunc(bool b) => Task.CompletedTask; var directories = new DirectoryPaths("projectDirectory", "latestArtifactsDirectory", "newArtifactsDirectory"); var sourcePaths = new DeploySourcePaths("newDacpacPath", "publishProfilePath", "previousDacpacPath"); var targetPaths = new DeployTargetPaths("deployScriptPath", "deployReportPath"); var paths = new PathCollection(directories, sourcePaths, targetPaths); var model = new ScriptCreationStateModel(project, configuration, previousVersion, true, HandlerFunc) { Paths = paths }; // Act await unit.Work(model, CancellationToken.None); // Assert Assert.AreEqual(StateModelState.DeletedRefactorLog, model.CurrentState); Assert.IsNull(model.Result); fsaMock.Verify(m => m.TryToCleanDirectory("projectDirectory", "*.refactorlog"), Times.Once); vsaMock.Verify(m => m.RemoveItemFromProjectRoot(project, It.IsAny <string>()), Times.Never); loggerMock.Verify(m => m.LogInfoAsync("Deleting refactorlog files ..."), Times.Once); loggerMock.Verify(m => m.LogTraceAsync("No files were deleted."), Times.Once); loggerMock.Verify(m => m.LogTraceAsync(It.Is <string>(s => s.StartsWith("Deleted file"))), Times.Never); }
public async Task Work_ScaffoldingStateModel_BuildFailed_Async() { // Arrange var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); var targetVersion = new Version(1, 2, 3); Task HandleWorkInProgressChanged(bool arg) => Task.CompletedTask; var model = new ScaffoldingStateModel(project, configuration, targetVersion, HandleWorkInProgressChanged); var bsMock = new Mock <IBuildService>(); bsMock.Setup(m => m.BuildProjectAsync(project)).ReturnsAsync(false); IWorkUnit <ScaffoldingStateModel> unit = new BuildProjectUnit(bsMock.Object); // Act await unit.Work(model, CancellationToken.None); // Assert Assert.AreEqual(StateModelState.TriedToBuildProject, model.CurrentState); Assert.IsFalse(model.Result); }
public void GetNextWorkUnit_ScriptCreationStateModel_CorrectWorkUnitForDeletedLatestArtifacts() { // Arrange var drMock = new Mock <IDependencyResolver>(); IWorkUnitFactory wuf = new WorkUnitFactory(drMock.Object); var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); var previousVersion = new Version(1, 0); Task HandlerFunc(bool b) => Task.CompletedTask; var model = new ScriptCreationStateModel(project, configuration, previousVersion, false, HandlerFunc) { CurrentState = StateModelState.DeletedLatestArtifacts }; // Act var workUnit = wuf.GetNextWorkUnit(model); // Assert Assert.IsNull(workUnit); }
public async Task DoWorkAsync_PreviousUnitFailed_Async() { // Arrange var loggerMock = new Mock <ILogger>(); var instance = new AsyncExecutorBaseTestImplementation(loggerMock.Object, () => { Assert.Fail("This shouldn't be called"); return(null); }); var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); var targetVersion = new Version(1, 0); var stateList = new List <bool>(); Task HandlerFunc(bool b) { stateList.Add(b); return(Task.CompletedTask); } var model = new ScaffoldingStateModel(project, configuration, targetVersion, HandlerFunc) { Result = false }; // Act await instance.CallDoWorkAsync(model, CancellationToken.None); // Assert Assert.IsFalse(model.Result); Assert.AreEqual(2, stateList.Count); Assert.IsTrue(stateList[0]); Assert.IsFalse(stateList[1]); loggerMock.Verify(m => m.LogInfoAsync("started"), Times.Once); loggerMock.Verify(m => m.LogInfoAsync("Creation was canceled by the user."), Times.Never); loggerMock.Verify(m => m.LogInfoAsync(It.Is <string>(s => s.StartsWith("completed stateModel in"))), Times.Once); }
public void GetNextWorkUnit_ScriptCreationStateModel_CorrectWorkUnitForModifiedDeploymentScript(bool createLatest) { // Arrange var fsaMock = Mock.Of <IFileSystemAccess>(); var vsaMock = Mock.Of <IVisualStudioAccess>(); var loggerMock = Mock.Of <ILogger>(); var expectedWorkUnit = new DeleteRefactorLogUnit(fsaMock, vsaMock, loggerMock); var drMock = new Mock <IDependencyResolver>(); drMock.Setup(m => m.Get <DeleteRefactorLogUnit>()).Returns(expectedWorkUnit); IWorkUnitFactory wuf = new WorkUnitFactory(drMock.Object); var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); var previousVersion = new Version(1, 0); Task HandlerFunc(bool b) => Task.CompletedTask; var model = new ScriptCreationStateModel(project, configuration, previousVersion, createLatest, HandlerFunc) { CurrentState = StateModelState.ModifiedDeploymentScript }; // Act var workUnit = wuf.GetNextWorkUnit(model); // Assert if (createLatest) { Assert.IsNull(workUnit); drMock.Verify(m => m.Get <DeleteRefactorLogUnit>(), Times.Never); } else { Assert.AreSame(expectedWorkUnit, workUnit); drMock.Verify(m => m.Get <DeleteRefactorLogUnit>(), Times.Once); } }
public async Task GetConfigurationOrDefaultAsync_Path_ErrorWhileReading_UseDefault_Async() { // Arrange var exception = new FileNotFoundException("foo"); var fsaMock = new Mock <IFileSystemAccess>(); fsaMock.Setup(m => m.CheckIfFileExists("C:\\Temp\\Test\\Properties\\ssdtlifecycle.json")) .Returns(true); fsaMock.Setup(m => m.ReadFileAsync("C:\\Temp\\Test\\Properties\\ssdtlifecycle.json")) .Throws(exception); var vsaMock = new Mock <IVisualStudioAccess>(); var loggerMock = new Mock <ILogger>(); IConfigurationService service = new ConfigurationService(fsaMock.Object, vsaMock.Object, loggerMock.Object); var defaultConfiguration = ConfigurationModel.GetDefault(); // Act var configuration = await service.GetConfigurationOrDefaultAsync("C:\\Temp\\Test\\Properties\\ssdtlifecycle.json"); // Assert Assert.IsNotNull(configuration); Assert.IsTrue(defaultConfiguration.Equals(configuration)); vsaMock.Verify(m => m.ShowModalError(It.Is <string>(s => s.Contains("Accessing the configuration file failed."))), Times.Once); loggerMock.Verify(m => m.LogErrorAsync(exception, It.Is <string>(s => s.Contains("Failed to read the configuration from file"))), Times.Once); }
public async Task Work_ScaffoldingStateModel_FormattedSuccessful_Async() { // Arrange var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); var targetVersion = new Version(1, 2, 3); var expectedFormattedTargetVersion = new Version(1, 2, 3, 0); Task HandleWorkInProgressChanged(bool arg) => Task.CompletedTask; var model = new ScaffoldingStateModel(project, configuration, targetVersion, HandleWorkInProgressChanged); var vsMock = new Mock <IVersionService>(); vsMock.Setup(m => m.FormatVersion(targetVersion, configuration)).Returns(expectedFormattedTargetVersion.ToString()); IWorkUnit <ScaffoldingStateModel> unit = new FormatTargetVersionUnit(vsMock.Object); // Act await unit.Work(model, CancellationToken.None); // Assert Assert.AreEqual(StateModelState.FormattedTargetVersionLoaded, model.CurrentState); Assert.IsNull(model.Result); Assert.AreEqual(expectedFormattedTargetVersion, model.FormattedTargetVersion); }
public async Task Work_ScriptCreationStateModel_PublishProfileValidation_Async(bool removeSqlCmdStatements, bool createNewDatabase, bool backupDatabaseBeforeChanges, bool scriptDatabaseOptions, bool scriptDeployStateChecks, bool?expectedResult) { // Arrange var daMock = new Mock <IDacAccess>(); daMock.Setup(m => m.CreateDeployFilesAsync("previousDacpacPath", "newDacpacPath", "publishProfilePath", true, true)) .ReturnsAsync(new CreateDeployFilesResult("pre script post", "report", "pre ", " post", new PublishProfile { CreateNewDatabase = createNewDatabase, BackupDatabaseBeforeChanges = backupDatabaseBeforeChanges, ScriptDatabaseOptions = scriptDatabaseOptions, ScriptDeployStateChecks = scriptDeployStateChecks })); var fsaMock = new Mock <IFileSystemAccess>(); var loggerMock = new Mock <ILogger>(); IWorkUnit <ScriptCreationStateModel> unit = new CreateDeploymentFilesUnit(daMock.Object, fsaMock.Object, loggerMock.Object); var project = new SqlProject("a", "b", "c"); var configuration = ConfigurationModel.GetDefault(); configuration.CreateDocumentationWithScriptCreation = true; configuration.RemoveSqlCmdStatements = removeSqlCmdStatements; var previousVersion = new Version(1, 0); Task HandlerFunc(bool b) => Task.CompletedTask; var directories = new DirectoryPaths("projectDirectory", "latestArtifactsDirectory", "newArtifactsDirectory"); var sourcePaths = new DeploySourcePaths("newDacpacPath", "publishProfilePath", "previousDacpacPath"); var targetPaths = new DeployTargetPaths("deployScriptPath", "deployReportPath"); var paths = new PathCollection(directories, sourcePaths, targetPaths); var model = new ScriptCreationStateModel(project, configuration, previousVersion, false, HandlerFunc) { Paths = paths }; // Act await unit.Work(model, CancellationToken.None); // Assert Assert.AreEqual(StateModelState.TriedToCreateDeploymentFiles, model.CurrentState); Assert.AreEqual(expectedResult, model.Result); if (removeSqlCmdStatements && createNewDatabase) { loggerMock.Verify(m => m.LogErrorAsync($"{nameof(PublishProfile.CreateNewDatabase)} cannot bet set to true, when {nameof(ConfigurationModel.RemoveSqlCmdStatements)} is also true."), Times.Once); } if (removeSqlCmdStatements && backupDatabaseBeforeChanges) { loggerMock.Verify(m => m.LogErrorAsync($"{nameof(PublishProfile.BackupDatabaseBeforeChanges)} cannot bet set to true, when {nameof(ConfigurationModel.RemoveSqlCmdStatements)} is also true."), Times.Once); } if (removeSqlCmdStatements && scriptDatabaseOptions) { loggerMock.Verify(m => m.LogErrorAsync($"{nameof(PublishProfile.ScriptDatabaseOptions)} cannot bet set to true, when {nameof(ConfigurationModel.RemoveSqlCmdStatements)} is also true."), Times.Once); } if (removeSqlCmdStatements && scriptDeployStateChecks) { loggerMock.Verify(m => m.LogErrorAsync($"{nameof(PublishProfile.ScriptDeployStateChecks)} cannot bet set to true, when {nameof(ConfigurationModel.RemoveSqlCmdStatements)} is also true."), Times.Once); } if (expectedResult == null) { fsaMock.Verify(m => m.WriteFileAsync("deployScriptPath", "pre script post"), Times.Once); fsaMock.Verify(m => m.WriteFileAsync("deployReportPath", "report"), Times.Once); } else { fsaMock.Verify(m => m.WriteFileAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Never); } }