public void GetNextWorkUnit_ScriptCreationStateModel_CorrectWorkUnitForTriedToCreateDeploymentFiles()
{
// Arrange
var mpsMock = Mock.Of <IScriptModifierProviderService>();
var fsaMock = Mock.Of <IFileSystemAccess>();
var loggerMock = Mock.Of <ILogger>();
var expectedWorkUnit = new ModifyDeploymentScriptUnit(mpsMock, fsaMock, loggerMock);
var drMock = new Mock <IDependencyResolver>();
drMock.Setup(m => m.Get <ModifyDeploymentScriptUnit>()).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, false, HandlerFunc)
{
CurrentState = StateModelState.TriedToCreateDeploymentFiles
};
// Act
var workUnit = wuf.GetNextWorkUnit(model);
// Assert
Assert.AreSame(expectedWorkUnit, workUnit);
drMock.Verify(m => m.Get <ModifyDeploymentScriptUnit>(), Times.Once);
}
public void GetNextWorkUnit_ScriptCreationStateModel_CorrectWorkUnitTriedToCleanArtifactsDirectory()
{
// Arrange
var bsMock = Mock.Of <IBuildService>();
var expectedWorkUnit = new CopyBuildResultUnit(bsMock);
var drMock = new Mock <IDependencyResolver>();
drMock.Setup(m => m.Get <CopyBuildResultUnit>()).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, false, HandlerFunc)
{
CurrentState = StateModelState.TriedToCleanArtifactsDirectory
};
// Act
var workUnit = wuf.GetNextWorkUnit(model);
// Assert
Assert.AreSame(expectedWorkUnit, workUnit);
drMock.Verify(m => m.Get <CopyBuildResultUnit>(), Times.Once);
}
public async Task Work_ScriptCreationStateModel_NoModifiers_Async()
{
// Arrange
var mpsMock = new Mock <IScriptModifierProviderService>();
var fsaMock = new Mock <IFileSystemAccess>();
var loggerMock = new Mock <ILogger>();
IWorkUnit <ScriptCreationStateModel> unit = new ModifyDeploymentScriptUnit(mpsMock.Object, fsaMock.Object, loggerMock.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);
mpsMock.Setup(m => m.GetScriptModifiers(configuration)).Returns(new Dictionary <ScriptModifier, IScriptModifier>());
// Act
await unit.Work(model, CancellationToken.None);
// Assert
Assert.AreEqual(StateModelState.ModifiedDeploymentScript, model.CurrentState);
Assert.IsNull(model.Result);
mpsMock.Verify(m => m.GetScriptModifiers(It.IsAny <ConfigurationModel>()), Times.Once);
fsaMock.Verify(m => m.ReadFileAsync(It.IsAny <string>()), Times.Never);
fsaMock.Verify(m => m.WriteFileAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
loggerMock.Verify(m => m.LogInfoAsync(It.IsAny <string>()), Times.Never);
}
public async Task Work_ScriptCreationStateModel_ValidVersion_Latest_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)
{
FormattedTargetVersion = null
};
var vsaMock = new Mock <IVisualStudioAccess>();
var loggerMock = new Mock <ILogger>();
IWorkUnit <ScriptCreationStateModel> unit = new ValidateTargetVersionUnit(vsaMock.Object, loggerMock.Object);
// Act
await unit.Work(model, CancellationToken.None);
// Assert
Assert.AreEqual(StateModelState.FormattedTargetVersionValidated, model.CurrentState);
Assert.IsNull(model.Result);
vsaMock.Verify(m => m.ShowModalError(It.IsAny <string>()), Times.Never);
loggerMock.Verify(m => m.LogErrorAsync(It.IsAny <string>()), Times.Never);
}
public void GetNextWorkUnit_ScriptCreationStateModel_CorrectWorkUnitForFormattedTargetVersionValidated()
{
// Arrange
var spsMock = Mock.Of <ISqlProjectService>();
var expectedWorkUnit = new LoadPathsUnit(spsMock);
var drMock = new Mock <IDependencyResolver>();
drMock.Setup(m => m.Get <LoadPathsUnit>()).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, false, HandlerFunc)
{
CurrentState = StateModelState.FormattedTargetVersionValidated
};
// Act
var workUnit = wuf.GetNextWorkUnit(model);
// Assert
Assert.AreSame(expectedWorkUnit, workUnit);
drMock.Verify(m => m.Get <LoadPathsUnit>(), Times.Once);
}
public async Task Work_ScriptCreationStateModel_InvalidVersion_Async(string previousVersionString)
{
// Arrange
var formattedTargetVersion = new Version(1, 2, 3);
var project = new SqlProject("a", "b", "c");
var configuration = ConfigurationModel.GetDefault();
var previousVersion = Version.Parse(previousVersionString);
Task HandleWorkInProgressChanged(bool arg) => Task.CompletedTask;
var model = new ScriptCreationStateModel(project, configuration, previousVersion, false, HandleWorkInProgressChanged)
{
FormattedTargetVersion = formattedTargetVersion
};
var vsaMock = new Mock <IVisualStudioAccess>();
var loggerMock = new Mock <ILogger>();
IWorkUnit <ScriptCreationStateModel> unit = new ValidateTargetVersionUnit(vsaMock.Object, loggerMock.Object);
// Act
await unit.Work(model, CancellationToken.None);
// Assert
Assert.AreEqual(StateModelState.FormattedTargetVersionValidated, model.CurrentState);
Assert.IsFalse(model.Result);
vsaMock.Verify(m => m.ShowModalError("Please change the DAC version in the SQL project settings (see output window)."), Times.Once);
loggerMock.Verify(m => m.LogErrorAsync(It.IsAny <string>()), Times.Once);
}
public async Task Work_ScriptCreationStateModel_CopyFailed_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 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, targetVersion, true, HandleWorkInProgressChanged)
{
Paths = paths
};
var bsMock = new Mock <IBuildService>();
bsMock.Setup(m => m.CopyBuildResultAsync(project, paths.Directories.NewArtifactsDirectory)).ReturnsAsync(false);
IWorkUnit <ScriptCreationStateModel> unit = new CopyBuildResultUnit(bsMock.Object);
// Act
await unit.Work(model, CancellationToken.None);
// Assert
Assert.AreEqual(StateModelState.TriedToCopyBuildResult, model.CurrentState);
Assert.IsFalse(model.Result);
}
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 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 spsMock = new Mock <ISqlProjectService>();
spsMock.Setup(m => m.TryLoadPathsForScriptCreationAsync(project, configuration, previousVersion, true)).ReturnsAsync(paths);
IWorkUnit <ScriptCreationStateModel> unit = new LoadPathsUnit(spsMock.Object);
// Act
await unit.Work(model, CancellationToken.None);
// Assert
Assert.AreEqual(StateModelState.PathsLoaded, model.CurrentState);
Assert.IsNull(model.Result);
}
public async Task Work_ScriptCreationStateModel_CompleteRun_NoFilesDeleted_ConfigurationDisabled_Async()
{
// Arrange
var fsaMock = new Mock <IFileSystemAccess>();
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 = false;
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(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
vsaMock.Verify(m => m.RemoveItemFromProjectRoot(project, It.IsAny <string>()), Times.Never);
loggerMock.Verify(m => m.LogInfoAsync(It.IsAny <string>()), Times.Never);
loggerMock.Verify(m => m.LogTraceAsync(It.IsAny <string>()), Times.Never);
}
public async Task Work_ScriptCreationStateModel_VerificationFailed_PublishProfilePathIsNotFilled_Async()
{
// Arrange
var project = new SqlProject("a", "b", "c");
var configuration = ConfigurationModel.GetDefault();
var previousVersion = new Version(1, 0);
Task HandleWorkInProgressChanged(bool arg) => Task.CompletedTask;
var directories = new DirectoryPaths("projectDirectory", "latestArtifactsDirectory", "newArtifactsDirectory");
var sourcePaths = new DeploySourcePaths("newDacpacPath", "", "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>();
var loggerMock = new Mock <ILogger>();
loggerMock.SetupGet(m => m.DocumentationBaseUrl).Returns("foobasebar");
IWorkUnit <ScriptCreationStateModel> unit = new VerifyPathsUnit(fsaMock.Object, loggerMock.Object);
// Act
await unit.Work(model, CancellationToken.None);
// Assert
Assert.AreEqual(StateModelState.PathsVerified, model.CurrentState);
Assert.IsFalse(model.Result);
loggerMock.Verify(m => m.LogErrorAsync(It.Is <string>(s => s.Contains(ConfigurationModel.UseSinglePublishProfileSpecialKeyword) && s.Contains("foobasebarpublish-profile-path"))), Times.Once);
fsaMock.Verify(m => m.CheckIfFileExists(It.IsAny <string>()), Times.Never);
}
public async Task Work_ScriptCreationStateModel_InvalidCharsInNewDacpacPath_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" + new string(Path.GetInvalidPathChars()), "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>();
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.IsFalse(model.Result);
fsaMock.Verify(m => m.EnsureDirectoryExists(It.IsAny <string>()), Times.Never);
fsaMock.Verify(m => m.CopyFile(It.IsAny <string>(), It.IsAny <string>()), Times.Never);
loggerMock.Verify(m => m.LogInfoAsync("Copying DACPAC to shared DACPAC repository ..."), Times.Once);
loggerMock.Verify(m => m.LogErrorAsync(It.Is <string>(s => s.StartsWith("Failed to copy DACPAC to shared DACPAC repository: "))), Times.Once);
}
public async Task Work_ScriptCreationStateModel_SkipBuild_Async()
{
// Arrange
var project = new SqlProject("a", "b", "c");
var configuration = ConfigurationModel.GetDefault();
configuration.BuildBeforeScriptCreation = false;
var previousVersion = new Version(1, 2, 3);
Task HandleWorkInProgressChanged(bool arg) => Task.CompletedTask;
var model = new ScriptCreationStateModel(project, configuration, previousVersion, true, HandleWorkInProgressChanged);
var bsMock = new Mock <IBuildService>();
bsMock.Setup(m => m.BuildProjectAsync(project)).ReturnsAsync(true);
IWorkUnit <ScriptCreationStateModel> unit = new BuildProjectUnit(bsMock.Object);
// Act
await unit.Work(model, CancellationToken.None);
// Assert
Assert.AreEqual(StateModelState.TriedToBuildProject, model.CurrentState);
Assert.IsNull(model.Result);
bsMock.Verify(m => m.BuildProjectAsync(project), Times.Never);
}
public async Task Work_ScriptCreationStateModel_CompleteRun_Async()
{
// Arrange
var fsaMock = new Mock <IFileSystemAccess>();
var loggerMock = new Mock <ILogger>();
IWorkUnit <ScriptCreationStateModel> unit = new CleanNewArtifactsDirectoryUnit(fsaMock.Object, loggerMock.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 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.TriedToCleanArtifactsDirectory, model.CurrentState);
Assert.IsNull(model.Result);
fsaMock.Verify(m => m.TryToCleanDirectory("newArtifactsDirectory"), Times.Once);
loggerMock.Verify(m => m.LogInfoAsync(It.IsNotNull <string>()), Times.Once);
}
public async Task Work_ScaffoldingStateModel_FormattedSuccessful_Async(bool latest)
{
// Arrange
var dacVersion = new Version(1, 2, 3);
var project = new SqlProject("a", "b", "c");
project.ProjectProperties.DacVersion = dacVersion;
var configuration = ConfigurationModel.GetDefault();
var previousVersion = new Version(1, 0);
var expectedFormattedTargetVersion = new Version(1, 2, 3, 0);
Task HandleWorkInProgressChanged(bool arg) => Task.CompletedTask;
var model = new ScriptCreationStateModel(project, configuration, previousVersion, latest, HandleWorkInProgressChanged);
var vsMock = new Mock <IVersionService>();
vsMock.Setup(m => m.FormatVersion(dacVersion, configuration)).Returns(expectedFormattedTargetVersion.ToString());
IWorkUnit <ScriptCreationStateModel> unit = new FormatTargetVersionUnit(vsMock.Object);
// Act
await unit.Work(model, CancellationToken.None);
// Assert
Assert.AreEqual(StateModelState.FormattedTargetVersionLoaded, model.CurrentState);
Assert.IsNull(model.Result);
if (latest)
{
Assert.IsNull(model.FormattedTargetVersion);
}
else
{
Assert.AreEqual(expectedFormattedTargetVersion, model.FormattedTargetVersion);
}
}
IWorkUnit <ScriptCreationStateModel> IWorkUnitFactory.GetNextWorkUnit(ScriptCreationStateModel stateModel)
{
if (stateModel == null)
{
throw new ArgumentNullException(nameof(stateModel));
}
switch (stateModel.CurrentState)
{
case StateModelState.Initialized:
return(_dependencyResolver.Get <LoadSqlProjectPropertiesUnit>());
case StateModelState.SqlProjectPropertiesLoaded:
return(_dependencyResolver.Get <FormatTargetVersionUnit>());
case StateModelState.FormattedTargetVersionLoaded:
return(_dependencyResolver.Get <ValidateTargetVersionUnit>());
case StateModelState.FormattedTargetVersionValidated:
return(_dependencyResolver.Get <LoadPathsUnit>());
case StateModelState.PathsLoaded:
return(_dependencyResolver.Get <VerifyPathsUnit>());
case StateModelState.PathsVerified:
return(_dependencyResolver.Get <BuildProjectUnit>());
case StateModelState.TriedToBuildProject:
return(_dependencyResolver.Get <CleanNewArtifactsDirectoryUnit>());
case StateModelState.TriedToCleanArtifactsDirectory:
return(_dependencyResolver.Get <CopyBuildResultUnit>());
case StateModelState.TriedToCopyBuildResult:
return(_dependencyResolver.Get <CopyDacpacToSharedDacpacRepositoryUnit>());
case StateModelState.TriedToCopyDacpacToSharedDacpacRepository:
return(_dependencyResolver.Get <CreateDeploymentFilesUnit>());
case StateModelState.TriedToCreateDeploymentFiles:
return(_dependencyResolver.Get <ModifyDeploymentScriptUnit>());
case StateModelState.ModifiedDeploymentScript:
return(stateModel.CreateLatest
? null
: _dependencyResolver.Get <DeleteRefactorLogUnit>());
case StateModelState.DeletedRefactorLog:
return(stateModel.CreateLatest
? null
: _dependencyResolver.Get <CleanLatestArtifactsDirectoryUnit>());
case StateModelState.DeletedLatestArtifacts:
return(null);
default:
throw new ArgumentOutOfRangeException(nameof(stateModel) + '.' + nameof(IStateModel.CurrentState));
}
}
public async Task Work_ScriptCreationStateModel_FailedToWriteModifiedScript_Async()
{
// Arrange
var exception = new IOException("foo");
const string baseScript = "foo bar";
const string expectedResultScript = "foo bar ab";
var smHeaderMock = new Mock <IScriptModifier>();
var smFooterMock = new Mock <IScriptModifier>();
var mpsMock = new Mock <IScriptModifierProviderService>();
var fsaMock = new Mock <IFileSystemAccess>();
fsaMock.Setup(m => m.ReadFileAsync("deployScriptPath"))
.ReturnsAsync(baseScript);
fsaMock.Setup(m => m.WriteFileAsync("deployScriptPath", It.IsAny <string>()))
.Throws(exception);
var loggerMock = new Mock <ILogger>();
IWorkUnit <ScriptCreationStateModel> unit = new ModifyDeploymentScriptUnit(mpsMock.Object, fsaMock.Object, loggerMock.Object);
var project = new SqlProject("a", "b", "c");
var configuration = ConfigurationModel.GetDefault();
var previousVersion = new Version(1, 0);
const bool createLatest = false;
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, createLatest, HandlerFunc)
{
Paths = paths
};
mpsMock.Setup(m => m.GetScriptModifiers(configuration)).Returns(new Dictionary <ScriptModifier, IScriptModifier>
{
{ ScriptModifier.AddCustomFooter, smFooterMock.Object },
{ ScriptModifier.AddCustomHeader, smHeaderMock.Object }
});
smHeaderMock.Setup(m => m.ModifyAsync(It.IsNotNull <ScriptModificationModel>()))
.Callback((ScriptModificationModel modificationModel) => modificationModel.CurrentScript += " a")
.Returns(Task.CompletedTask);
smFooterMock.Setup(m => m.ModifyAsync(It.IsNotNull <ScriptModificationModel>()))
.Callback((ScriptModificationModel modificationModel) => modificationModel.CurrentScript += "b")
.Returns(Task.CompletedTask);
// Act
await unit.Work(model, CancellationToken.None);
// Assert
Assert.AreEqual(StateModelState.ModifiedDeploymentScript, model.CurrentState);
Assert.IsFalse(model.Result);
mpsMock.Verify(m => m.GetScriptModifiers(It.IsAny <ConfigurationModel>()), Times.Once);
fsaMock.Verify(m => m.ReadFileAsync(paths.DeployTargets.DeployScriptPath), Times.Once);
fsaMock.Verify(m => m.WriteFileAsync(paths.DeployTargets.DeployScriptPath, expectedResultScript), Times.Once);
loggerMock.Verify(m => m.LogInfoAsync(It.IsAny <string>()), Times.Exactly(2));
smHeaderMock.Verify(m => m.ModifyAsync(It.IsNotNull <ScriptModificationModel>()), Times.Once);
smFooterMock.Verify(m => m.ModifyAsync(It.IsNotNull <ScriptModificationModel>()), Times.Once);
loggerMock.Verify(m => m.LogErrorAsync(exception, "Failed to write the modified script"), Times.Once);
}
Task IWorkUnit <ScriptCreationStateModel> .Work(ScriptCreationStateModel stateModel,
CancellationToken cancellationToken)
{
if (stateModel == null)
{
throw new ArgumentNullException(nameof(stateModel));
}
return(TryBuildInternal(stateModel, stateModel.Project, stateModel.Configuration.BuildBeforeScriptCreation));
}
Task IWorkUnit <ScriptCreationStateModel> .Work(ScriptCreationStateModel stateModel,
CancellationToken cancellationToken)
{
if (stateModel == null)
{
throw new ArgumentNullException(nameof(stateModel));
}
return(TryLoadSqlProjectPropertiesInternal(stateModel, stateModel.Project));
}
Task IWorkUnit <ScriptCreationStateModel> .Work(ScriptCreationStateModel stateModel,
CancellationToken cancellationToken)
{
if (stateModel == null)
{
throw new ArgumentNullException(nameof(stateModel));
}
return(CleanArtifactsDirectoryInternal(stateModel, stateModel.Paths));
}
Task IWorkUnit <ScriptCreationStateModel> .Work(ScriptCreationStateModel stateModel,
CancellationToken cancellationToken)
{
if (stateModel == null)
{
throw new ArgumentNullException(nameof(stateModel));
}
return(ValidateTargetVersionInternal(stateModel,
sm => sm.CreateLatest || sm.FormattedTargetVersion > sm.PreviousVersion,
sm => $"DacVersion of SQL project ({sm.FormattedTargetVersion}) is equal to or smaller than the previous version ({sm.PreviousVersion})."));
}
Task IWorkUnit <ScriptCreationStateModel> .Work(ScriptCreationStateModel stateModel,
CancellationToken cancellationToken)
{
if (stateModel == null)
{
throw new ArgumentNullException(nameof(stateModel));
}
return(TryCopyInternal(stateModel,
stateModel.Paths.DeploySources.NewDacpacPath,
stateModel.Configuration.SharedDacpacRepositoryPath));
}
Task IWorkUnit <ScriptCreationStateModel> .Work(ScriptCreationStateModel stateModel,
CancellationToken cancellationToken)
{
if (stateModel == null)
{
throw new ArgumentNullException(nameof(stateModel));
}
return(LoadPathsInternal(stateModel,
async sm => sm.Paths = await _sqlProjectService.TryLoadPathsForScriptCreationAsync(stateModel.Project,
stateModel.Configuration,
stateModel.PreviousVersion,
stateModel.CreateLatest),
sm => sm.Paths));
}
Task IWorkUnit <ScriptCreationStateModel> .Work(ScriptCreationStateModel stateModel,
CancellationToken cancellationToken)
{
if (stateModel == null)
{
throw new ArgumentNullException(nameof(stateModel));
}
if (!stateModel.CreateLatest)
{
stateModel.FormattedTargetVersion = Version.Parse(_versionService.FormatVersion(stateModel.Project.ProjectProperties.DacVersion, stateModel.Configuration));
}
stateModel.CurrentState = StateModelState.FormattedTargetVersionLoaded;
return(Task.CompletedTask);
}
public async Task Work_ScriptCreationStateModel_CreateScriptAndReport_Async(bool includePreDeployment, bool includePostDeployment)
{
// Arrange
var daMock = new Mock <IDacAccess>();
daMock.Setup(m => m.CreateDeployFilesAsync("previousDacpacPath", "newDacpacPath", "publishProfilePath", true, true))
.ReturnsAsync(new CreateDeployFilesResult((includePreDeployment ? "pre " : "") + "script" + (includePostDeployment ? " post" : ""),
"report",
includePreDeployment ? "pre " : null,
includePostDeployment ? " post" : null,
new PublishProfile()));
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;
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.IsNull(model.Result);
fsaMock.Verify(m => m.WriteFileAsync(It.IsAny <string>(), It.IsAny <string>()), Times.Exactly(2));
fsaMock.Verify(m => m.WriteFileAsync("deployScriptPath", (includePreDeployment ? "pre " : "") + "script" + (includePostDeployment ? " post" : "")), Times.Once);
fsaMock.Verify(m => m.WriteFileAsync("deployReportPath", "report"), Times.Once);
loggerMock.Verify(m => m.LogDebugAsync("Previous DACPAC path: \"previousDacpacPath\""), Times.Once);
loggerMock.Verify(m => m.LogDebugAsync("New DACPAC path: \"newDacpacPath\""), Times.Once);
loggerMock.Verify(m => m.LogDebugAsync("Publish profile path: \"publishProfilePath\""), Times.Once);
loggerMock.Verify(m => m.LogDebugAsync(It.Is <string>(s => s.StartsWith("Current working directory: \"") && s.EndsWith("\""))), 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 void FormattedTargetVersion_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 formattedVersion = new Version(1, 0, 0);
// Act
model.FormattedTargetVersion = formattedVersion;
// Assert
Assert.AreSame(formattedVersion, model.FormattedTargetVersion);
}
public void Constructor_CorrectInitialization()
{
// 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;
// Act
var model = new ScriptCreationStateModel(project, configuration, previousVersion, true, changeHandler);
// Assert
Assert.AreSame(project, model.Project);
Assert.AreSame(configuration, model.Configuration);
Assert.AreSame(previousVersion, model.PreviousVersion);
Assert.IsTrue(model.CreateLatest);
Assert.AreSame(changeHandler, model.HandleWorkInProgressChanged);
}
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 void GetNextWorkUnit_ScriptCreationStateModel_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 previousVersion = new Version(1, 0);
Task HandlerFunc(bool b) => Task.CompletedTask;
var model = new ScriptCreationStateModel(project, configuration, previousVersion, false, HandlerFunc)
{
CurrentState = state
};
// Act & Assert
// ReSharper disable once AssignNullToNotNullAttribute
Assert.Throws <ArgumentOutOfRangeException>(() => wuf.GetNextWorkUnit(model));
}
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 Work_ScriptCreationStateModel_LoadFailed_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.TryLoadPathsForScriptCreationAsync(project, configuration, previousVersion, true)).ReturnsAsync(null as PathCollection);
IWorkUnit <ScriptCreationStateModel> unit = new LoadPathsUnit(spsMock.Object);
// Act
await unit.Work(model, CancellationToken.None);
// Assert
Assert.AreEqual(StateModelState.PathsLoaded, model.CurrentState);
Assert.IsFalse(model.Result);
}
