private ExcecutionResult ExecuteNonTransactionalCreateDatabaseSqlScripts(
DatabaseConnectionParameters connectionParameters,
Dictionary <string, FileInfo> filesToExecute,
Encoding encodingForReadingSqlScripts)
{
IDbConnection connection = CreateDbConnection(connectionParameters);
TransactionalSqlFileExecutor sqlFileExecutor = new TransactionalSqlFileExecutor(connection, _outputLogger);
try
{
sqlFileExecutor.ExecuteNonTransactional(filesToExecute.Select(item => item.Key).ToList(), encodingForReadingSqlScripts);
}
catch (TransactionalSqlFileExecutorException exception)
{
var result = new ExcecutionResult {
Success = false
};
result.Errors.Add(exception.Message);
result.Errors.Add(exception.InnerException.Message);
return(result);
}
return(new ExcecutionResult {
Success = true
});
}
public virtual ExcecutionResult ExecuteCreateDatabase(
DatabaseConnectionParameters connectionParameters,
Encoding encodingForReadingSqlScripts)
{
// Execute optional FileStructurePolicy
if (_createDatabasePolicy != null)
{
PolicyResult policyResult = _createDatabasePolicy.Check(_databaseScriptsDirInfo);
if (!policyResult.Success)
{
// Policy failed Return errors
ExcecutionResult result = new ExcecutionResult {
Success = false
};
result.Errors.AddRange(policyResult.Messages);
return(result);
}
}
SqlFilesListReader filesReader = new SqlFilesListReader(_databaseScriptsDirInfo);
Dictionary <string, FileInfo> filesToExecute = filesReader.GetCreateDatabaseFileToExecute();
return(ExecuteNonTransactionalCreateDatabaseSqlScripts(connectionParameters, filesToExecute, encodingForReadingSqlScripts));
}
public void ShouldCallExecuteCreateDatabaseWhenBeforeExecuteScriptsActionIsCreateDatabase()
{
// arrange
DatabaseReleaseTool databaseReleaseToolMock =
MockRepository.GeneratePartialMock <DatabaseReleaseTool>(
Environment.CurrentDirectory,
new CreateDatabasePolicyComposite(),
new FileStructurePolicyComposite(),
new ConsoleOutputLogger(),
new ConnectionStringFactory(),
null);
DatabaseConnectionParameters databaseConnectionParameters = new DatabaseConnectionParameters
{
BeforeExecuteScriptsAction =
BeforeExecuteScriptsAction
.CreateDatabase
};
databaseReleaseToolMock.Expect(x => x.ExecuteCreateDatabase(databaseConnectionParameters, Encoding.ASCII))
.Repeat.Once()
.Return(new ExcecutionResult());
// act
databaseReleaseToolMock.Execute(string.Empty, string.Empty, databaseConnectionParameters, Encoding.ASCII);
// assert
databaseReleaseToolMock.VerifyAllExpectations();
}
ShouldCallExecuteCreateDatabaseAndExecuteAllScriptsForDatabaseWhenBeforeExecuteScriptsActionIsCreateDatabaseAndANdResultOfExecuteCreateDatabaseIsSucces()
{
// arrange
DatabaseReleaseTool databaseReleaseToolMock =
MockRepository.GeneratePartialMock <DatabaseReleaseTool>(
Environment.CurrentDirectory,
new CreateDatabasePolicyComposite(),
new FileStructurePolicyComposite(),
new ConsoleOutputLogger(),
new ConnectionStringFactory(),
null);
DatabaseConnectionParameters databaseConnectionParameters = new DatabaseConnectionParameters
{
BeforeExecuteScriptsAction =
BeforeExecuteScriptsAction
.CreateDatabase
};
databaseReleaseToolMock.Expect(x => x.ExecuteCreateDatabase(databaseConnectionParameters, Encoding.UTF7))
.Repeat.Once()
.Return(new ExcecutionResult {
Success = true
});
databaseReleaseToolMock.Expect(
x => x.ExecuteAllScriptsForDatabase("1.0.0", "2.0.0", databaseConnectionParameters, Encoding.UTF7))
.Repeat.Once()
.Return(new ExcecutionResult());
// act
databaseReleaseToolMock.Execute("1.0.0", "2.0.0", databaseConnectionParameters, Encoding.UTF7);
// assert
databaseReleaseToolMock.VerifyAllExpectations();
}
public void ShouldThrowFileNotFoundExceptionWhenParameterSpecifiesConfigFileThatDoesNotExist()
{
DatabaseConnectionParameters fromFileParameters = new DatabaseConnectionParameters
{
ConfigurationFileName =
"IDoNoTExist.config",
CreationType =
ConnectionStringCreationType
.FromConfigurationFile
};
Assert.That(() => { _connectionStringFactory.Create(fromFileParameters); }, Throws.TypeOf(typeof(FileNotFoundException)));
}
public void ShouldUseDbConnectionToMasterWhenBeforeExecuteScriptsActionIsCreateDatabase()
{
// Arrange
DirectoryInfo directoryInfo =
DirectoryStructureHelper.CreateValidDatabaseDirStructure(
"ShouldUseDbConnectionToMasterWhenBeforeExecuteScriptsActionIsCreateDatabase");
DirectoryStructureHelper.CreateEmptyFile(Path.Combine(directoryInfo.GetDirectories()[1].FullName, "CreateDatabase.sql"));
IDatabaseConnectionFactory databaseConnectionFactory = MockRepository.GenerateMock <IDatabaseConnectionFactory>();
IDbConnection connection = MockRepository.GenerateStub <IDbConnection>();
IDbTransaction transaction = MockRepository.GenerateStub <IDbTransaction>();
IDbCommand command = MockRepository.GenerateStub <IDbCommand>();
databaseConnectionFactory.Expect(
c => c.CreateDatabaseConnection("Data Source=.;Initial Catalog=master;User ID=testUser;Password=testPassword", DatabaseType.MsSql))
.Repeat.Once()
.Return(connection);
connection.Expect(method => method.BeginTransaction()).Return(transaction);
connection.Expect(method => method.CreateCommand()).Return(command);
DatabaseReleaseTool dbreleaseTool = new DatabaseReleaseTool(
directoryInfo.FullName,
new CreateDatabasePolicyComposite(),
null,
new ConsoleOutputLogger(),
new ConnectionStringFactory(),
databaseConnectionFactory);
DatabaseConnectionParameters parameters = new DatabaseConnectionParameters
{
BeforeExecuteScriptsAction =
BeforeExecuteScriptsAction.CreateDatabase,
DatabaseType = DatabaseType.MsSql,
CreationType =
ConnectionStringCreationType.FromArguments,
Arguments =
{
Hostname = ".",
Username = "******",
Password = "******",
Database = "FruitDB"
}
};
// Act
dbreleaseTool.ExecuteCreateDatabase(parameters, Encoding.Default);
// Assert
databaseConnectionFactory.VerifyAllExpectations();
}
public void ShouldCreateConnectionStringFromConfigurationFile()
{
// Arrange
DatabaseConnectionParameters fromFileParameters = new DatabaseConnectionParameters
{
ConfigurationFileName = "TestConfig.config",
CreationType =
ConnectionStringCreationType
.FromConfigurationFile
};
// Act
string connectionString = _connectionStringFactory.Create(fromFileParameters);
// Assert
Assert.That(connectionString, Is.EqualTo("Data Source=.;Initial Catalog=testdb;User ID=xx;Password=xxxx"));
}
public void SmokeTest()
{
// Setup
DirectoryInfo directoryInfo = DirectoryStructureHelper.CreateValidDatabaseDirStructure("SmokeTest");
DirectoryStructureHelper.CreateEmptyFile(Path.Combine(directoryInfo.GetDirectories()[1].FullName, "CreateDatabase.sql"));
IDatabaseConnectionFactory databaseConnectionFactory = MockRepository.GenerateMock <IDatabaseConnectionFactory>();
IDbConnection connection = MockRepository.GenerateStub <IDbConnection>();
IDbTransaction transaction = MockRepository.GenerateStub <IDbTransaction>();
IDbCommand command = MockRepository.GenerateStub <IDbCommand>();
databaseConnectionFactory.Expect(
c => c.CreateDatabaseConnection("Data Source=.;Initial Catalog=master;User ID=testUser;Password=testPassword", DatabaseType.MsSql))
.Repeat.Once()
.Return(connection);
connection.Expect(method => method.BeginTransaction()).Return(transaction);
connection.Expect(method => method.CreateCommand()).Return(command);
DatabaseReleaseTool dbreleaseTool = new DatabaseReleaseTool(
directoryInfo.FullName,
new CreateDatabasePolicyComposite(),
null,
new ConsoleOutputLogger(),
new ConnectionStringFactory(),
databaseConnectionFactory);
DatabaseConnectionParameters parameters = new DatabaseConnectionParameters();
parameters.BeforeExecuteScriptsAction = BeforeExecuteScriptsAction.CreateDatabase;
parameters.DatabaseType = DatabaseType.MsSql;
parameters.CreationType = ConnectionStringCreationType.FromArguments;
parameters.Arguments.Hostname = ".";
parameters.Arguments.Username = "******";
parameters.Arguments.Password = "******";
parameters.Arguments.Database = "testdb";
// Act
ExcecutionResult result = dbreleaseTool.ExecuteCreateDatabase(parameters, Encoding.Default);
// Assert
Assert.That(result.Success, Is.True, "error: {0} ", result.Errors);
}
public void ExecuteAllScriptsForDatabaseSmokeTest()
{
// Setup
string pathName = "ExecuteAllScriptsForDatabaseSmokeTest";
DirectoryInfo directoryInfo = DirectoryStructureHelper.CreateValidDatabaseDirStructure(pathName);
DirectoryStructureHelper.CreateEmptyFile(Path.Combine(directoryInfo.GetDirectories()[1].FullName, "1.0_TestScript.sql"));
IFileStructurePolicy fileStucturePolicyComposite = new FileStructurePolicyComposite();
IDatabaseConnectionFactory connectionFactory = CreateMockDatabaseConnectionFactory();
IOutputLogger outputLogger = new ConsoleOutputLogger();
DatabaseReleaseTool dbreleaseTool = new DatabaseReleaseTool(
directoryInfo.FullName,
null,
fileStucturePolicyComposite,
outputLogger,
_connectionStringFactory,
connectionFactory);
string fromVersion = "1.0.0.0";
string toVersion = "2.0";
DatabaseConnectionParameters parameters = new DatabaseConnectionParameters {
DatabaseType = DatabaseType.MsSql
};
parameters.CreationType = ConnectionStringCreationType.FromArguments;
parameters.Arguments.Hostname = ".";
parameters.Arguments.Username = "******";
parameters.Arguments.Password = "******";
parameters.Arguments.Database = "testdatabase";
// Act
ExcecutionResult result = dbreleaseTool.ExecuteAllScriptsForDatabase(fromVersion, toVersion, parameters, null);
Assert.IsTrue(result.Success, string.Join("|", result.Errors.ToArray()));
Assert.IsEmpty(result.Errors);
}
public ExcecutionResult Execute(
string fromVersion,
string toVersion,
DatabaseConnectionParameters connectionParameters,
Encoding encodingForReadingSqlScripts)
{
var excecutionResult = new ExcecutionResult {
Success = true
};
if (connectionParameters.BeforeExecuteScriptsAction == BeforeExecuteScriptsAction.CreateDatabase)
{
excecutionResult = ExecuteCreateDatabase(connectionParameters, encodingForReadingSqlScripts);
}
if (excecutionResult.Success)
{
excecutionResult = ExecuteAllScriptsForDatabase(fromVersion, toVersion, connectionParameters, encodingForReadingSqlScripts);
}
return(excecutionResult);
}
public virtual ExcecutionResult ExecuteAllScriptsForDatabase(
string fromVersion,
string toVersion,
DatabaseConnectionParameters connectionParameters,
Encoding encodingForReadingSqlScripts)
{
if (string.IsNullOrEmpty(fromVersion))
{
throw new ArgumentException(@"Cannot be null or empty.", "fromVersion");
}
if (string.IsNullOrEmpty(toVersion))
{
throw new ArgumentException(@"Cannot be null or empty.", "toVersion");
}
if (encodingForReadingSqlScripts == null)
{
encodingForReadingSqlScripts = Encoding.Default;
}
Version fromVersionObject;
Version toVersionObject;
try
{
fromVersionObject = VersionNumberHelper.RemoveNegativeNumbersFromVersionObject(new Version(fromVersion));
}
catch (Exception ex)
{
var result = new ExcecutionResult {
Success = false
};
result.Errors.Add(
string.Format("Invalid fromVersion. Could not parse fromVersion to a usable version object. {0}", ex.Message));
return(result);
}
try
{
toVersionObject = VersionNumberHelper.RemoveNegativeNumbersFromVersionObject(new Version(toVersion));
}
catch (Exception ex)
{
var result = new ExcecutionResult {
Success = false
};
result.Errors.Add(string.Format("Invalid toVersion. Could not parse toVersion to a usable version object. {0}", ex.Message));
return(result);
}
// Execute optional FileStructurePolicy
if (_fileStructurePolicy != null)
{
PolicyResult policyResult = _fileStructurePolicy.Check(_databaseScriptsDirInfo);
if (!policyResult.Success)
{
// Policy failed Return errors
ExcecutionResult result = new ExcecutionResult {
Success = false
};
result.Errors.AddRange(policyResult.Messages);
return(result);
}
}
SqlFilesListReader filesReader = new SqlFilesListReader(_databaseScriptsDirInfo);
Dictionary <string, FileInfo> filesToExecute = filesReader.GetSpecificVersionedFilesToExecute(fromVersionObject, toVersionObject);
return(ExecuteSqlScripts(connectionParameters, filesToExecute, encodingForReadingSqlScripts));
}
private IDbConnection CreateDbConnection(DatabaseConnectionParameters connectionParameters)
{
string connectionString = _connectionStringFactory.Create(connectionParameters);
return(_databaseConnectionFactory.CreateDatabaseConnection(connectionString, connectionParameters.DatabaseType));
}
public void SetUp()
{
_parameters = CreateTestParameters();
}
private static int Main(string[] args)
{
if (args.Length == 0)
{
PrintUsage();
return(-1);
}
// Initialize default values
ApplicationOptions options = optionsParser.Parse(args);
if (options.InformationSwitch == InformationSwitch.On)
{
// Print extra info
PrintUsage();
PrintDatabaseDirectoryStructureTemplate();
return(-2);
}
ArgumentValidationResult validationResult = argumentValidator.Validate(args);
if (validationResult.Status == ArgumentValidationStatus.Failed)
{
outputLogger.WriteErrorMessage("\nArgument error:\n");
validationResult.ValidationMessages.ForEach(
item => outputLogger.WriteErrorMessage(string.Format(CultureInfo.InvariantCulture, "\t{0}\n", item)));
PrintUsage();
return(-3);
}
DatabaseReleaseTool databaseReleaseTool;
try
{
databaseReleaseTool = new DatabaseReleaseTool(
options.DatabaseScriptsPath,
new CreateDatabasePolicyComposite(),
new FileStructurePolicyComposite(),
outputLogger,
new ConnectionStringFactory(),
new DatabaseConnectionFactory());
}
catch (Exception ex)
{
outputLogger.WriteErrorMessage(string.Format("Error while creating databasereleasetool. {0}.", ex.Message));
outputLogger.WriteDebugMessage(ex.StackTrace);
return(-5);
}
DatabaseConnectionParameters connectionParameters = new DatabaseConnectionParameters();
// Check if a configuration file parameter is passed.
// If so then the database configuration will be read from the config file instead of the commandline.
if (!string.IsNullOrEmpty(options.ConfigurationFilename))
{
// Check with configfile
outputLogger.WriteInfoMessage("Starting DatabaseRelease Tool in ConfigFile Modus.");
outputLogger.WriteDebugMessage(
string.Format(CultureInfo.InvariantCulture, "ConfigFile: {0}.", options.ConfigurationFilename));
outputLogger.WriteDebugMessage(
string.Format(CultureInfo.InvariantCulture, "Database Path: {0}.", options.DatabaseScriptsPath));
// Create databasesettings with configfile.
connectionParameters.CreationType = ConnectionStringCreationType.FromConfigurationFile;
connectionParameters.ConfigurationFileName = options.ConfigurationFilename;
connectionParameters.BeforeExecuteScriptsAction =
GetBeforeExecuteScriptsActionFromConfigurationFile(options.ConfigurationFilename);
}
else
{
// check with databaseparams
connectionParameters.CreationType = ConnectionStringCreationType.FromArguments;
connectionParameters.BeforeExecuteScriptsAction = options.BeforeExecuteScriptsAction;
connectionParameters.Arguments.Hostname = options.Servername;
connectionParameters.Arguments.Database = options.DatabaseName;
connectionParameters.Arguments.Username = options.Username;
connectionParameters.Arguments.Password = options.Password;
}
// DatabaseType is given
if (options.DatabaseType != DatabaseType.None)
{
DatabaseType type = options.DatabaseType;
// database type is mssql by default.
connectionParameters.DatabaseType = type;
outputLogger.WriteInfoMessage(string.Format(CultureInfo.InvariantCulture, "DatabaseType is: {0}.", type));
}
else
{
connectionParameters.DatabaseType = DatabaseType.MsSql; // default;
// Create databasesettings with parameters.
outputLogger.WriteInfoMessage("No DatabaseType was given using default MsSql.");
}
ExcecutionResult result;
try
{
result = databaseReleaseTool.Execute(
options.FromVersion,
options.ToVersion,
connectionParameters,
options.EncodingForReadingSqlScripts);
}
catch (Exception ex)
{
outputLogger.WriteErrorMessage(
string.Format(CultureInfo.InvariantCulture, "Unexpected error while Executing scripts. {0}.", ex.Message));
outputLogger.WriteDebugMessage(ex.StackTrace);
return(-6);
}
if (!result.Success)
{
outputLogger.WriteErrorMessage("Excecution failed with the following errors: ");
outputLogger.WriteErrorMessage(string.Join("\n", result.Errors.ToArray()));
return(-10);
}
outputLogger.WriteSuccessMessage("Execution succeeded.");
return(0);
}
