public void Updates_database()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, "c:\\scripts");
taskAttributes.RequestedDatabaseAction = RequestedDatabaseAction.Update;
var mocks = new MockRepository();
var scriptfolderexecutor = mocks.StrictMock<IScriptFolderExecutor>();
var queryexecutor = mocks.StrictMock<IQueryExecutor>();
queryexecutor.Stub(x => x.CheckDatabaseExists(taskAttributes.ConnectionSettings)).Return(true);
var taskObserver = mocks.StrictMock<ITaskObserver>();
using (mocks.Record())
{
taskObserver.Log(string.Format("Run scripts in Update folder."));
scriptfolderexecutor.ExecuteScriptsInFolder(taskAttributes, "Update", taskObserver);
taskObserver.Log(string.Format("Run scripts in Everytime folder."));
scriptfolderexecutor.ExecuteChangedScriptsInFolder(taskAttributes, "Everytime", taskObserver);
taskObserver.Log(string.Format("Run scripts in RunAlways folder."));
scriptfolderexecutor.ExecuteRunAlwaysScriptsInFolder(taskAttributes, "RunAlways", taskObserver);
}
using (mocks.Playback())
{
IDatabaseActionExecutor updater = new DatabaseUpdater(scriptfolderexecutor, queryexecutor);
updater.Execute(taskAttributes, taskObserver);
}
mocks.VerifyAll();
}
/// <summary>
/// Runs larger queries that may be multiline separated with GO
/// Runs entire sql block in a single transaction that will rollback if any part of the query errors
/// </summary>
/// <param name="settings"></param>
/// <param name="sql"></param>
public void ExecuteNonQueryTransactional(ConnectionSettings settings, string sql)
{
//do all this in a single transaction
using (var scope = new TransactionScope())
{
string connectionString = _connectionStringGenerator.GetConnectionString(settings, true);
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
using (var command = new SqlCommand())
{
command.Connection = connection;
command.CommandTimeout = 0;
var scripts = SplitSqlStatements(sql);
foreach (var splitScript in scripts)
{
command.CommandText = splitScript;
try
{
command.ExecuteNonQuery();
}
catch (Exception ex)
{
ex.Data.Add("Custom", "Erroring script was run in a transaction and was rolled back.");
throw ex;
}
}
}
scope.Complete();
}
}
}
public void Should_not_fail_if_datebase_does_not_exist()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, null);
var mocks = new MockRepository();
var connectionDropper = mocks.DynamicMock<IDatabaseConnectionDropper>();
var taskObserver = mocks.StrictMock<ITaskObserver>();
var queryExecutor = mocks.StrictMock<IQueryExecutor>();
using (mocks.Record())
{
Expect.Call(() => taskObserver.Log("Running against: SQL Server"));
Expect.Call(queryExecutor.ReadFirstColumnAsStringArray(settings, "select @@version")).Return(new string[] { "SQL Server" });
Expect.Call(() => taskObserver.Log("Dropping database: db\n"));
Expect.Call(() => queryExecutor.ExecuteNonQuery(settings, "ALTER DATABASE [db] SET SINGLE_USER WITH ROLLBACK IMMEDIATE drop database [db]"))
.Throw(new Exception("foo message"));
Expect.Call(() => taskObserver.Log("Database 'db' could not be dropped."));
}
using (mocks.Playback())
{
IDatabaseActionExecutor dropper = new DatabaseDropper(connectionDropper, queryExecutor);
dropper.Execute(taskAttributes, taskObserver);
}
mocks.VerifyAll();
}
public void Update_Database_Runs_New_Everytime_Script()
{
//arrange
string scriptsDirectory = Path.Combine("Scripts",GetType().Name.Replace("Tester", ""));
string scriptFileMd5 = ChangeScriptExecutor.GetFileMD5Hash(Path.Combine(scriptsDirectory,"Everytime", "TestScript.sql"));
var settings = new ConnectionSettings(".\\sqlexpress", "aliasqltest", true, null, null);
new ConsoleAliaSQL().UpdateDatabase(settings, scriptsDirectory, RequestedDatabaseAction.Drop);
//act
bool success = new ConsoleAliaSQL().UpdateDatabase(settings, scriptsDirectory, RequestedDatabaseAction.Update);
//assert
int records = 0;
AssertUsdAppliedDatabaseScriptTable(settings, reader =>
{
while (reader.Read())
{
records++;
reader["ScriptFile"].ShouldEqual("TestScript.sql");
reader["hash"].ShouldEqual(scriptFileMd5);
}
});
success.ShouldEqual(true);
records.ShouldEqual(1);
}
public void ExecuteIfChanged(string fullFilename, ConnectionSettings settings, ITaskObserver taskObserver, bool logOnly = false)
{
string scriptFilename = getFilename(fullFilename);
var scriptFileMD5 = GetFileMD5Hash(fullFilename);
if (_executionTracker.EverytimeScriptShouldBeExecuted(settings, scriptFilename, scriptFileMD5))
{
if (!logOnly)
{
string sql = _fileSystem.ReadTextFile(fullFilename);
taskObserver.Log(string.Format("Executing: {0}{1}", getLastFolderName(fullFilename), scriptFilename));
_executor.ExecuteNonQuery(settings, sql, true);
}
else
{
taskObserver.Log(string.Format("Executing: {0}{1} in log only mode", getLastFolderName(fullFilename), scriptFilename));
}
_executionTracker.MarkScriptAsExecuted(settings, scriptFilename, taskObserver, scriptFileMD5);
}
else
{
taskObserver.Log(string.Format("Skipping (unchanged): {0}{1}", getLastFolderName(fullFilename), scriptFilename));
}
}
public void Manages_database()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var scriptDirectory = @"c:\scripts";
var taskAttributes = new TaskAttributes(settings, scriptDirectory);
taskAttributes.RequestedDatabaseAction= RequestedDatabaseAction.Create;
var mocks = new MockRepository();
var taskObserver = mocks.StrictMock<ITaskObserver>();
var generator = mocks.StrictMock<ILogMessageGenerator>();
var factory = mocks.StrictMock<IDatabaseActionExecutorFactory>();
var creator = mocks.StrictMock<IDatabaseActionExecutor>();
var updater = mocks.StrictMock<IDatabaseActionExecutor>();
var executors = new IDatabaseActionExecutor[] { creator, updater };
using (mocks.Record())
{
Expect.Call(generator.GetInitialMessage(taskAttributes)).Return("starting...");
taskObserver.Log("starting...");
Expect.Call(factory.GetExecutors(RequestedDatabaseAction.Create)).Return(executors);
creator.Execute(taskAttributes, taskObserver);
updater.Execute(taskAttributes, taskObserver);
}
using (mocks.Playback())
{
ISqlDatabaseManager manager = new SqlDatabaseManager(generator, factory);
manager.Upgrade(taskAttributes, taskObserver);
}
mocks.VerifyAll();
}
public void Execute(string fullFilename, ConnectionSettings settings, ITaskObserver taskObserver, bool logOnly = false)
{
string scriptFilename = getFilename(fullFilename);
if (_executionTracker.ScriptAlreadyExecuted(settings, scriptFilename))
{
taskObserver.Log(string.Format("Skipping (already executed): {0}{1}", getLastFolderName(fullFilename),scriptFilename));
}
else
{
if (!logOnly)
{
string sql = _fileSystem.ReadTextFile(fullFilename);
if (!ScriptSupportsTransactions(sql))
{
taskObserver.Log(string.Format("Executing: {0}{1}", getLastFolderName(fullFilename),scriptFilename));
_executor.ExecuteNonQuery(settings, sql, true);
}
else
{
taskObserver.Log(string.Format("Executing: {0}{1} in a transaction", getLastFolderName(fullFilename),scriptFilename));
_executor.ExecuteNonQueryTransactional(settings, sql);
}
}
else
{
taskObserver.Log(string.Format("Executing: {0}{1} in log only mode",getLastFolderName(fullFilename), scriptFilename));
}
_executionTracker.MarkScriptAsExecuted(settings, scriptFilename, taskObserver);
}
}
public void Executes_all_the_scripts_within_a_folder()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var sqlFiles = new[] { "c:\\scripts\\Update\\001.sql", "c:\\scripts\\Update\\002_data_.sql", "c:\\scripts\\Update\\003.sql" };
var taskAttributes = new TaskAttributes(settings, "c:\\scripts")
{
RequestedDatabaseAction = RequestedDatabaseAction.Update,
};
var mocks = new MockRepository();
var initializer = mocks.StrictMock<ISchemaInitializer>();
var fileLocator = mocks.StrictMock<ISqlFileLocator>();
var executor = mocks.StrictMock<IChangeScriptExecutor>();
var testdataexecutor = mocks.StrictMock<ITestDataScriptExecutor>();
var versioner = mocks.StrictMock<IDatabaseVersioner>();
var taskObserver = mocks.StrictMock<ITaskObserver>();
using (mocks.Record())
{
initializer.EnsureSchemaCreated(settings);
Expect.Call(fileLocator.GetSqlFilenames("c:\\scripts", "Update")).Return(sqlFiles);
executor.Execute("c:\\scripts\\Update\\001.sql", settings, taskObserver);
executor.Execute("c:\\scripts\\Update\\002_data_.sql", settings, taskObserver);
executor.Execute("c:\\scripts\\Update\\003.sql", settings, taskObserver);
versioner.VersionDatabase(settings, taskObserver);
}
using (mocks.Playback())
{
IScriptFolderExecutor folderExecutor = new ScriptFolderExecutor(initializer, fileLocator, executor, testdataexecutor, versioner);
folderExecutor.ExecuteScriptsInFolder(taskAttributes, "Update", taskObserver);
}
mocks.VerifyAll();
}
public void Update_Database_Runs_Changed_Everytime_Script()
{
//arrange
string scriptsDirectory = Path.Combine("Scripts", GetType().Name.Replace("Tester", ""));
var settings = new ConnectionSettings(".\\sqlexpress", "aliasqltest", true, null, null);
new ConsoleAliaSQL().UpdateDatabase(settings, scriptsDirectory, RequestedDatabaseAction.Drop);
//act
//run once
new ConsoleAliaSQL().UpdateDatabase(settings, scriptsDirectory, RequestedDatabaseAction.Update).ShouldBeTrue();
new QueryExecutor().ExecuteScalarInteger(settings, "select 1 from dbo.sysobjects where name = 'TestTable' and type='U'").ShouldEqual(1);
//change contents of script
File.WriteAllText(Path.Combine(scriptsDirectory, "Everytime", "TestScript.sql"), "CREATE TABLE [dbo].[TestTable2]([Id] [int] IDENTITY(1,1) NOT NULL, [FullName] [nvarchar](50) NULL)");
new ConsoleAliaSQL().UpdateDatabase(settings, scriptsDirectory, RequestedDatabaseAction.Update).ShouldBeTrue();
//assert
new QueryExecutor().ExecuteScalarInteger(settings, "select 1 from dbo.sysobjects where name = 'TestTable2' and type='U'").ShouldEqual(1);
//change contents of script back in case you run again without rebuilding
File.WriteAllText(Path.Combine(scriptsDirectory, "Everytime", "TestScript.sql"), "CREATE TABLE [dbo].[TestTable]([Id] [int] IDENTITY(1,1) NOT NULL, [FullName] [nvarchar](50) NULL)");
}
public void Drops_Azure_database_without_dropping_connections()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, null);
var mocks = new MockRepository();
var connectionDropper = mocks.StrictMock<IDatabaseConnectionDropper>();
var taskObserver = mocks.StrictMock<ITaskObserver>();
var queryExecutor = mocks.StrictMock<IQueryExecutor>();
using (mocks.Record())
{
Expect.Call(() => taskObserver.Log("Running against: SQL Azure"));
Expect.Call(queryExecutor.ReadFirstColumnAsStringArray(settings, "select @@version")).Return(new string[] { "SQL Azure" });
queryExecutor.ExecuteNonQuery(settings, "drop database [db]");
Expect.Call(() => taskObserver.Log("Dropping database: db\n"));
}
using (mocks.Playback())
{
IDatabaseActionExecutor dropper = new DatabaseDropper(connectionDropper, queryExecutor);
dropper.Execute(taskAttributes, taskObserver);
}
mocks.VerifyAll();
}
public void Creates_database()
{
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, "c:\\scripts");
taskAttributes.RequestedDatabaseAction= RequestedDatabaseAction.Create;
var mocks = new MockRepository();
var queryExecutor = mocks.StrictMock<IQueryExecutor>();
var executor = mocks.StrictMock<IScriptFolderExecutor>();
var taskObserver = mocks.StrictMock<ITaskObserver>();
using (mocks.Record())
{
queryExecutor.ExecuteNonQuery(settings, "create database [db]");
taskObserver.Log(string.Format("Run scripts in Create folder."));
executor.ExecuteScriptsInFolder(taskAttributes, "Create", taskObserver);
}
using (mocks.Playback())
{
IDatabaseActionExecutor creator = new DatabaseCreator(queryExecutor, executor);
creator.Execute(taskAttributes, taskObserver);
}
mocks.VerifyAll();
}
public void ProperlyComparesTwoNonIdenticalConnectionSettings()
{
ConnectionSettings settings1 = new ConnectionSettings("server", "database", true, "username", "password");
ConnectionSettings settings2 = new ConnectionSettings("server1", "database", true, "username", "password");
Assert.AreNotEqual(settings1, settings2);
}
public bool CheckDatabaseExists(ConnectionSettings settings)
{
bool result;
var tmpConn = new SqlConnection(_connectionStringGenerator.GetConnectionString(settings, false));
try
{
string sqlCreateDbQuery = string.Format("SELECT database_id FROM sys.databases WHERE Name = '{0}'", settings.Database);
using (tmpConn)
{
using (var sqlCmd = new SqlCommand(sqlCreateDbQuery, tmpConn))
{
tmpConn.Open();
var databaseId = (int)sqlCmd.ExecuteScalar();
tmpConn.Close();
result = (databaseId > 0);
}
}
}
catch (Exception)
{
result = false;
}
return result;
}
/// <summary>
/// Runs queries that are not specific to a database such as Drop, Create, single user mode
/// </summary>
/// <param name="settings"></param>
/// <param name="sql"></param>
/// <param name="includeDatabaseName"></param>
public void ExecuteNonQuery(ConnectionSettings settings, string sql, bool includeDatabaseName = false)
{
string connectionString = _connectionStringGenerator.GetConnectionString(settings, includeDatabaseName);
using (var connection = new SqlConnection(connectionString))
{
connection.Open();
using (var command = new SqlCommand())
{
command.Connection = connection;
command.CommandTimeout = 0;
var scripts = SplitSqlStatements(sql);
foreach (var splitScript in scripts)
{
command.CommandText = splitScript;
try
{
command.ExecuteNonQuery();
}
catch (Exception ex)
{
ex.Data.Add("Custom", "Erroring script was not run in a transaction and may be partially committed.");
throw ex;
}
}
}
}
}
public void Execute(string fullFilename, ConnectionSettings settings, ITaskObserver taskObserver)
{
string scriptFilename = getFilename(fullFilename);
if (_executionTracker.TestDataScriptAlreadyExecuted(settings, scriptFilename))
{
taskObserver.Log(string.Format("Skipping (already executed): {0}", scriptFilename));
}
else
{
string sql = _fileSystem.ReadTextFile(fullFilename);
if (!_executor.ScriptSupportsTransactions(sql))
{
taskObserver.Log(string.Format("Executing: {0}", scriptFilename));
_executor.ExecuteNonQuery(settings, sql, true);
_executionTracker.MarkTestDataScriptAsExecuted(settings, scriptFilename, taskObserver);
}
else
{
taskObserver.Log(string.Format("Executing: {0} in a transaction", scriptFilename));
_executor.ExecuteNonQueryTransactional(settings, sql);
_executionTracker.MarkTestDataScriptAsExecuted(settings, scriptFilename, taskObserver);
}
}
}
public void Correctly_drops_connections()
{
string assembly = SqlDatabaseManager.SQL_FILE_ASSEMBLY;
string sqlFile = string.Format(SqlDatabaseManager.SQL_FILE_TEMPLATE, "DropConnections");
ConnectionSettings settings = new ConnectionSettings("server", "MyDatabase", true, null, null);
MockRepository mocks = new MockRepository();
ITaskObserver taskObserver = mocks.StrictMock<ITaskObserver>();
IResourceFileLocator fileLocator = mocks.StrictMock<IResourceFileLocator>();
ITokenReplacer replacer = mocks.StrictMock<ITokenReplacer>();
IQueryExecutor queryExecutor = mocks.StrictMock<IQueryExecutor>();
using (mocks.Record())
{
taskObserver.Log("Dropping connections for database MyDatabase\n");
Expect.Call(fileLocator.ReadTextFile(assembly, sqlFile)).Return("Unformatted SQL");
replacer.Text = "Unformatted SQL";
replacer.Replace("DatabaseName", "MyDatabase");
Expect.Call(replacer.Text).Return("Formatted SQL");
queryExecutor.ExecuteNonQuery(settings, "Formatted SQL");
}
using (mocks.Playback())
{
IDatabaseConnectionDropper dropper = new DatabaseConnectionDropper(fileLocator, replacer, queryExecutor);
dropper.Drop(settings, taskObserver);
}
mocks.VerifyAll();
}
public void UpdateDatabaseTester()
{
//arrange
string scriptsDirectory = Path.Combine("Scripts", GetType().Name.Replace("Tester", ""));
var settings = new ConnectionSettings(".\\sqlexpress", "aliasqltest", true, null, null);
new DbUpdater().UpdateDatabase(new ConnectionStringGenerator().GetConnectionString(settings, true), RequestedDatabaseAction.Drop, scriptsDirectory);
//act
bool success = new DbUpdater().UpdateDatabase(new ConnectionStringGenerator().GetConnectionString(settings, true), RequestedDatabaseAction.Create, scriptsDirectory).Success;
//assert
int records = 0;
AssertUsdAppliedDatabaseScriptTable(settings, reader =>
{
while (reader.Read())
{
records++;
reader["ScriptFile"].ShouldEqual("0001-Update.sql");
}
});
success.ShouldEqual(true);
records.ShouldEqual(1);
}
public void Versions_database()
{
string assembly = SqlDatabaseManager.SQL_FILE_ASSEMBLY;
string sqlFile = string.Format(SqlDatabaseManager.SQL_FILE_TEMPLATE, "VersionDatabase");
ConnectionSettings settings = new ConnectionSettings(String.Empty, String.Empty, false, String.Empty, String.Empty);
string sqlScript = "SQL script...";
MockRepository mocks = new MockRepository();
IResourceFileLocator fileLocator = mocks.StrictMock<IResourceFileLocator>();
IQueryExecutor queryExecutor = mocks.StrictMock<IQueryExecutor>();
ITaskObserver taskObserver = mocks.StrictMock<ITaskObserver>();
using (mocks.Record())
{
Expect.Call(fileLocator.ReadTextFile(assembly, sqlFile)).Return(sqlScript);
Expect.Call(queryExecutor.ExecuteScalarInteger(settings, sqlScript)).Return(7);
taskObserver.SetVariable("usdDatabaseVersion", "7");
}
using (mocks.Playback())
{
IDatabaseVersioner versioner = new DatabaseVersioner(fileLocator, queryExecutor);
versioner.VersionDatabase(settings, taskObserver);
}
mocks.VerifyAll();
}
public void MarkTestDataScriptAsExecuted(ConnectionSettings settings, string scriptFilename, ITaskObserver task)
{
string insertTemplate =
"insert into usd_AppliedDatabaseTestDataScript (ScriptFile, DateApplied) values ('{0}', getdate())";
string sql = string.Format(insertTemplate, scriptFilename);
_executor.ExecuteNonQueryTransactional(settings, sql);
}
public void EnsureTestDataSchemaCreated(ConnectionSettings settings)
{
string assembly = SqlDatabaseManager.SQL_FILE_ASSEMBLY;
string sqlFile = string.Format(SqlDatabaseManager.SQL_FILE_TEMPLATE, "CreateTestDataSchema");
string sql = _locator.ReadTextFile(assembly, sqlFile);
_executor.ExecuteNonQueryTransactional(settings, sql);
}
public void VersionDatabase(ConnectionSettings settings, ITaskObserver taskObserver)
{
string assembly = SqlDatabaseManager.SQL_FILE_ASSEMBLY;
string sqlFile = string.Format(SqlDatabaseManager.SQL_FILE_TEMPLATE, "VersionDatabase");
string sql = _fileLocator.ReadTextFile(assembly, sqlFile);
string version = _executor.ExecuteScalarInteger(settings, sql).ToString();
taskObserver.SetVariable(_databaseVersionPropertyName, version);
}
public void CorrectlyGeneratesConnectionStringWithDatabaseAndUserSecurityAndDatabaseExcluded()
{
IConnectionStringGenerator generator = new ConnectionStringGenerator();
ConnectionSettings settings = new ConnectionSettings("server", "db", false, "usr", "pwd");
string connString = generator.GetConnectionString(settings, false);
Assert.AreEqual("Data Source=server;User ID=usr;Password=pwd;", connString);
}
public void CorrectlyGeneratesConnectionStringWithDatabaseAndIntegratedSecurityAndDatabaseExcluded()
{
IConnectionStringGenerator generator = new ConnectionStringGenerator();
ConnectionSettings settings = new ConnectionSettings("server", "db", true, string.Empty, string.Empty);
string connString = generator.GetConnectionString(settings, false);
Assert.AreEqual("Data Source=server;Integrated Security=True;", connString);
}
public void Creates_initial_log_message_for_database_drop()
{
ILogMessageGenerator generator = new LogMessageGenerator();
var settings = new ConnectionSettings("server", "db", true, null, null);
var taskAttributes = new TaskAttributes(settings, "c:\\scripts") {RequestedDatabaseAction = RequestedDatabaseAction.Drop};
string message = generator.GetInitialMessage(taskAttributes);
Assert.That(message, Is.EqualTo("Drop db on server\n"));
}
public void PropertyAccessorsWorkProperly()
{
ConnectionSettings settings = new ConnectionSettings("server", "database", true, "username", "password");
Assert.AreEqual("server", settings.Server);
Assert.AreEqual("database", settings.Database);
Assert.AreEqual(true, settings.IntegratedAuthentication);
Assert.AreEqual("username", settings.Username);
Assert.AreEqual("password", settings.Password);
}
public bool TestDataScriptAlreadyExecuted(ConnectionSettings settings, string scriptFilename)
{
if (_appliedScripts == null)
{
_appliedScripts =
_executor.ReadFirstColumnAsStringArray(settings, "select ScriptFile from usd_AppliedDatabaseTestDataScript");
}
bool alreadyExecuted = Array.IndexOf(_appliedScripts, scriptFilename) >= 0;
return alreadyExecuted;
}
public bool EverytimeScriptShouldBeExecuted(ConnectionSettings settings, string scriptFilename, string md5)
{
bool shouldBeExecuted = false;
if (ScriptAlreadyExecuted(settings, scriptFilename))
{
var filehash = _executor.ReadFirstColumnAsStringArray(settings,"select hash from usd_AppliedDatabaseScript where ScriptFile = '" + scriptFilename + "'");
shouldBeExecuted = filehash.Any() && (filehash[0] != md5);
}
else
{
shouldBeExecuted = true;
}
return shouldBeExecuted;
}
public void MarkScriptAsExecuted(ConnectionSettings settings, string scriptFilename, ITaskObserver task, string hash = "")
{
//for everytime scripts just delete the row. We could update it but either way has the same result
if (!string.IsNullOrEmpty(hash))
{
string deleteTemplate = "delete from usd_AppliedDatabaseScript where ScriptFile = '{0}'";
string deletesql = string.Format(deleteTemplate, scriptFilename);
_executor.ExecuteNonQueryTransactional(settings, deletesql);
}
string insertTemplate = "insert into usd_AppliedDatabaseScript (ScriptFile, DateApplied, hash) values ('{0}', getdate(), '{1}')";
string sql = string.Format(insertTemplate, scriptFilename, hash);
_executor.ExecuteNonQueryTransactional(settings, sql);
}
public void Update_Database_ShouldRun_Old_RunAlways_Script()
{
//arrange
string scriptsDirectory = Path.Combine("Scripts", GetType().Name.Replace("Tester", ""));
var settings = new ConnectionSettings(".\\sqlexpress", "aliasqltest", true, null, null);
new ConsoleAliaSQL().UpdateDatabase(settings, scriptsDirectory, RequestedDatabaseAction.Drop);
//act
//run once
new ConsoleAliaSQL().UpdateDatabase(settings, scriptsDirectory, RequestedDatabaseAction.Update).ShouldBeTrue();
new QueryExecutor().ExecuteScalarInteger(settings, "select 1 from dbo.sysobjects where name = 'TestTable' and type='U'").ShouldEqual(1);
var dateApplied = DateTime.MinValue;
QueryUsdAppliedDatabaseScriptTable(settings, reader =>
{
while (reader.Read())
{
reader["ScriptFile"].ShouldEqual("TestScript.sql");
dateApplied = (DateTime)reader["DateApplied"];
}
});
dateApplied.ShouldBeGreaterThan(DateTime.MinValue);
//delete TestTable to ensure script doesn't run again
new QueryExecutor().ExecuteNonQuery(settings, "drop table TestTable", true);
//run again
bool success = new ConsoleAliaSQL().UpdateDatabase(settings, scriptsDirectory, RequestedDatabaseAction.Update);
//assert
new QueryExecutor().ExecuteScalarInteger(settings, "select 1 from dbo.sysobjects where name = 'TestTable' and type='U'").ShouldEqual(1);
DateTime dateAppliedUpdated = DateTime.MinValue; ;
int records = 0;
QueryUsdAppliedDatabaseScriptTable(settings, reader =>
{
while (reader.Read())
{
records++;
reader["ScriptFile"].ShouldEqual("TestScript.sql");
dateAppliedUpdated = (DateTime) reader["DateApplied"];
}
});
success.ShouldBeTrue();
records.ShouldEqual(1);
dateAppliedUpdated.ShouldBeGreaterThan(dateApplied);
}
public void PendingChangesTester()
{
//arrange
string scriptsDirectory = Path.Combine("Scripts", GetType().Name.Replace("Tester", ""));
var settings = new ConnectionSettings(".\\sqlexpress", "aliasqltest", true, null, null);
new DbUpdater().UpdateDatabase(new ConnectionStringGenerator().GetConnectionString(settings, true), RequestedDatabaseAction.Drop, scriptsDirectory);
bool updated = new DbUpdater().UpdateDatabase(new ConnectionStringGenerator().GetConnectionString(settings, true), RequestedDatabaseAction.Update, scriptsDirectory).Success;
//act
List<string> pendingChanges = new DbUpdater().PendingChanges(new ConnectionStringGenerator().GetConnectionString(settings, true), scriptsDirectory.Replace("DbUpdater", "NewEverytimeScript"));
//assert
pendingChanges.Count.ShouldEqual(1);
}
