public void RunMigrationScriptError_Test()
{
bool executed = false;
UnityCache.RegisterInstance <IFaustAccessor>(new Fakes.StubIFaustAccessor
{
ExecuteSqlCommandStringUserContext = (command, userContext) =>
{
executed = true;
throw new Exception();
}
});
FaustMigrationScript script = new FaustMigrationScript
{
ReleaseNumber = 1,
ScriptName = "UnitTestScript",
Commands = new string[] { "Command 1" }
};
FaustMigrationHistory result = new FaustEngine().RunMigrationScript(script, new UserContext());
Assert.IsTrue(executed);
Assert.IsFalse(result.Successful.Value);
Assert.IsNotNull(result);
}
public FaustMigrationHistory RunMigrationScript(FaustMigrationScript script, UserContext userContext)
{
Logger.Log(string.Format("FaustEngine.RunMigrationScript: Running commands for script {0}.", script.ScriptName), TraceEventType.Verbose);
FaustMigrationHistory migrationHistory = new FaustMigrationHistory();
try
{
migrationHistory.ReleaseNumber = script.ReleaseNumber;
migrationHistory.ScriptName = script.ScriptName;
migrationHistory.Committed = true;
migrationHistory.Successful = true;
migrationHistory.LastRun = DateTime.Now;
foreach (string sqlCommand in script.Commands)
{
migrationHistory.Log = sqlCommand;
UnityCache.Resolve <IFaustAccessor>().ExecuteSqlCommand(sqlCommand, userContext);
}
return(migrationHistory);
}
catch (Exception ex)
{
migrationHistory.Successful = false;
migrationHistory.Log = string.Format("Error: {0}\r\nCommand: {1}", ex.Message, migrationHistory.Log);
Logger.Log(string.Format("FaustEngine.RunMigrationScript: {0}", migrationHistory.Log), TraceEventType.Error);
return(migrationHistory);
}
}
public void SaveMigrationsHistoryUpdate_Test()
{
bool created = false;
bool updated = false;
UnityCache.RegisterInstance <IFaustMigrationsHistoryAccessor>(new Fakes.StubIFaustMigrationsHistoryAccessor
{
FindManyFaustMigrationHistoryUserContext = (history, userContext) =>
{
return(new FaustMigrationHistory[] { new FaustMigrationHistory() });
},
CreateFaustMigrationHistoryUserContext = (history, userContext) =>
{
created = true;
return(new FaustMigrationHistory());
},
UpdateFaustMigrationHistoryUserContext = (history, userContext) =>
{
updated = true;
return(new FaustMigrationHistory());
}
});
new FaustEngine().SaveMigrationsHistory(new FaustMigrationHistory[] { new FaustMigrationHistory() }, new UserContext());
Assert.IsFalse(created);
Assert.IsTrue(updated);
}
public void SaveMigrationsHistory(FaustMigrationHistory[] migrationHistories, UserContext userContext)
{
Logger.Log(string.Format("FaustEngine.SaveMigrationsHistory: Saving History for {0} scripts.", migrationHistories.Length), TraceEventType.Verbose);
foreach (FaustMigrationHistory migration in migrationHistories)
{
FaustMigrationHistory searchCriteria = new FaustMigrationHistory
{
ReleaseNumber = migration.ReleaseNumber,
ScriptName = migration.ScriptName
};
using (TransactionScope loggingScope = new TransactionScope(TransactionScopeOption.RequiresNew))
{
FaustMigrationHistory existingHistory = UnityCache.Resolve <IFaustMigrationsHistoryAccessor>()
.FindMany(searchCriteria, userContext)
.FirstOrDefault();
if (existingHistory == null)
{
UnityCache.Resolve <IFaustMigrationsHistoryAccessor>().Create(migration, userContext);
}
else
{
existingHistory.LastRun = migration.LastRun;
existingHistory.Committed = migration.Committed;
existingHistory.Successful = migration.Successful;
existingHistory.Log = migration.Log;
UnityCache.Resolve <IFaustMigrationsHistoryAccessor>().Update(existingHistory, userContext);
}
loggingScope.Complete();
}
}
}
// GET: Registration
public ActionResult Index()
{
List <Attendee> attendees = new List <Attendee>();
UserContext uc = new UserContext();
uc.ConnectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
attendees = UnityCache.ResolveDefault <IRegistrationManager>().GetAllAttendees(uc).ToList();
return(View(attendees));
}
static void Main(string[] args)
{
DalGeneratorConfigSection config = DalGeneratorConfigSection.current;
UnityCache.Resolve <IDalManager>().CreateDataContracts();
UnityCache.Resolve <IDalManager>().CreateFluentApiEntries();
UnityCache.Resolve <IDalManager>().CreateDatabaseAccessors();
UnityCache.Resolve <IDalManager>().CreateUnitTests();
}
public ProgramTestsBase()
{
UnityCache.Register(Mock.Create <IDependency>());
#region JustMock Full Required
Mock.Arrange(() => Logger.Log(Arg.AnyString)).DoNothing();
#endregion
}
public ActionResult Create(Attendee attendee)
{
List <Attendee> attendees = new List <Attendee>();
attendees.Add(attendee);
IRegistrationManager regManager = UnityCache.ResolveDefault <IRegistrationManager>();
UserContext uc = new UserContext();
uc.ConnectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
regManager.ProcessRegistration(uc, attendees);
return(View());
}
public ActionResult Create(List <Attendee> attendees)
{
IRegistrationManager regManager = UnityCache.ResolveDefault <IRegistrationManager>();
UserContext uc = new UserContext();
uc.AuditUserName = "******";
uc.ConnectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
var reg = regManager.ProcessRegistration(uc, attendees);
return(View());
}
public void ProcessRegistration(UserContext userContext, ICollection <Attendee> attendees)
{
Registration returnRegistration = new Registration();
List <Attendee> registrationAttendees = new List <Attendee>(UnityCache.ResolveDefault <IRegistrationEngine>().ProcessAttendees(userContext, attendees));
Registration newReg = new Registration();
newReg.Attendees = registrationAttendees;
UnityCache.ResolveDefault <IRegistrationAccessor>().AddRegistration(userContext, newReg);
}
public void CreateDataContracts()
{
DalGeneratorConfigSection config = DalGeneratorConfigSection.current;
foreach (IncludedTablesElement table in config.IncludedTables)
{
InformationSchemaColumn[] columns = UnityCache.Resolve <IDatabaseAccessor>().GetColumnsForTable(table.Name, table.Schema);
string tableName = columns.First().TABLE_NAME.TrimEnd(new char[] { 's' });
UnityCache.Resolve <IDalEngine>().GenerateCodeFile(config.TemplatesPath, "DataContract.cshtml", config.DataContractsPath, tableName, columns);
}
}
public ICollection <Attendee> ProcessAttendees(UserContext userContext, ICollection <Attendee> attendees)
{
List <Attendee> registrationAttendees = new List <Attendee>();
foreach (Attendee attendee in attendees)
{
Attendee CheckedAttendee = new Attendee();
CheckedAttendee = UnityCache.ResolveDefault <IRegistrationAccessor>().FindAttendee(userContext, attendee);
registrationAttendees.Add(CheckedAttendee);
}
return(registrationAttendees);
}
public void BasicTest()
{
bool initialized = false;
bool debugDeleted = false;
bool gotScripts = false;
bool ranScript = false;
bool savedHistory = false;
UnityCache.RegisterInstance <IFaustMigrationsHistoryAccessor>(new Fakes.StubIFaustMigrationsHistoryAccessor
{
InitializeUserContext = (userContext) =>
{
initialized = true;
},
DeleteDebugEntriesUserContext = (userContext) =>
{
debugDeleted = true;
return(new FaustMigrationHistory[] { });
}
});
UnityCache.RegisterInstance <IFaustEngine>(new Fakes.StubIFaustEngine
{
GetReleaseMigrationScriptsDirectoryInfoUserContext = (releaseDir, userContext) =>
{
gotScripts = true;
return(new FaustMigrationScript[] { new FaustMigrationScript() });
},
RunMigrationScriptFaustMigrationScriptUserContext = (script, userContext) =>
{
ranScript = true;
return(new FaustMigrationHistory());
},
SaveMigrationsHistoryFaustMigrationHistoryArrayUserContext = (histories, userContext) =>
{
savedHistory = true;
}
});
new FaustManager().RunMigration("unitTest");
Assert.IsTrue(initialized);
Assert.IsTrue(debugDeleted);
Assert.IsTrue(gotScripts);
Assert.IsTrue(ranScript);
Assert.IsTrue(savedHistory);
}
public ICollection <Attendee> ProcessAttendees(UserContext userContext, ICollection <Attendee> attendees)
{
List <Attendee> registrationAttendees = new List <Attendee>();
foreach (Attendee a in attendees)
{
if (a.Id == null)
{
registrationAttendees.Add(UnityCache.ResolveDefault <IAttendeeAccessor>().AddAttendee(userContext, a));
}
else
{
registrationAttendees.Add(a);
}
}
return(registrationAttendees);
}
public void CreateUnitTests()
{
DalGeneratorConfigSection config = DalGeneratorConfigSection.current;
UnityCache.Resolve <IDalEngine>().GenerateCodeFile(config.TemplatesPath, "DatabaseAccessorTestBase.cshtml", config.UnitTestsPath, "DatabaseAccessorTestBase");
foreach (IncludedTablesElement table in DalGeneratorConfigSection.current.IncludedTables)
{
List <InformationSchemaColumn> columns = UnityCache.Resolve <IDatabaseAccessor>()
.GetColumnsForTable(table.Name, table.Schema)
.ToList();
string tableName = columns.First().TABLE_NAME.TrimEnd(new char[] { 's' });
string accessorFile = string.Format("{0}AccessorTests", tableName);
UnityCache.Resolve <IDalEngine>().GenerateCodeFile(config.TemplatesPath, "DatabaseAccessorUnitTest.cshtml", config.UnitTestsPath, accessorFile, tableName);
}
}
public void GetReleaseMigrationScripts_TestFindOne()
{
bool foundMany = false;
UnityCache.RegisterInstance <IFaustMigrationsHistoryAccessor>(new Fakes.StubIFaustMigrationsHistoryAccessor
{
FindManyFaustMigrationHistoryUserContext = (history, userContext) => {
foundMany = true;
return(new FaustMigrationHistory[] {});
}
});
DirectoryInfo releaseDir = new DirectoryInfo(@"..\..\migrations\UnitTest\001");
FaustMigrationScript[] results = new FaustEngine().GetReleaseMigrationScripts(releaseDir, new UserContext());
Assert.IsTrue(foundMany);
Assert.AreEqual(1, results.Length);
}
public static void RunMigrations(string[] args)
{
if (args.Length > 0)
{
if (!string.IsNullOrEmpty(ConfigurationManager.AppSettings[args[0]]))
{
UnityCache.Resolve <IFaustManager>().RunMigration(args[0]);
}
else
{
Console.WriteLine("##teamcity[message text='Specified database does not exist in App.config' errorDetails='' status='ERROR']");
Console.WriteLine("##teamcity[buildProblem description='FAUST Failed. See build log for details.']");
}
}
else
{
UnityCache.Resolve <IFaustManager>().RunMigration(ConfigurationManager.AppSettings["DefaultDatabase"]);
}
}
private void LoadChangelogFromCache(string appSecret)
{
try
{
var cacheValue = new UnityCache(appSecret).GetValue("app-changelog", null);
if (cacheValue == null)
{
return;
}
var versions = JsonConvert.DeserializeObject <AppVersion[]>(cacheValue);
CreateChangelog(versions);
}
catch (Exception)
{
// ignore
}
}
public void CreateFluentApiEntries()
{
DalGeneratorConfigSection config = DalGeneratorConfigSection.current;
// Create DbBase.cs File
UnityCache.Resolve <IDalEngine>().GenerateCodeFile(config.TemplatesPath, "DbBase.cshtml", config.AccessorsPath, "DbBase");
// Create DbContext class
List <TableColumnContext> contexts = new List <TableColumnContext>();
foreach (IncludedTablesElement table in DalGeneratorConfigSection.current.IncludedTables)
{
List <TablePrimaryKey> primaryKeys = UnityCache.Resolve <IDatabaseAccessor>()
.GetPrimaryKeysForTable(table.Name, table.Schema)
.ToList();
List <InformationSchemaColumn> columns = UnityCache.Resolve <IDatabaseAccessor>()
.GetColumnsForTable(table.Name, table.Schema)
.ToList();
List <String> allIdColumns = columns.Where(c => c.COLUMN_NAME.EndsWith("Id"))
.Where(c => !primaryKeys.Any(k => k.COLUMN_NAME == c.COLUMN_NAME))
.Select(c => c.COLUMN_NAME).ToList();
contexts.Add(new TableColumnContext
{
TableNamePlural = table.Name,
TableNameSingular = table.Name.TrimEnd(new char[] { 's' }),
SchemaName = table.Schema,
IdentityColumns = columns.Where(c => c.IsIdentity).Select(c => c.COLUMN_NAME).ToList(),
PrimaryKeys = primaryKeys,
AllIds = allIdColumns
});
}
UnityCache.Resolve <IDalEngine>().GenerateCodeFile(config.TemplatesPath, "DbContext.cshtml", config.AccessorsPath, config.DbContextClassName, contexts);
}
public FaustMigrationScript[] GetReleaseMigrationScripts(DirectoryInfo release, UserContext userContext)
{
Logger.Log(string.Format("FaustEngine.GetReleaseMigrationScripts: Getting migrationscripts for release {0}.", release.Name), TraceEventType.Verbose);
IEnumerable <FileInfo> files = release.EnumerateFiles().Where(file => file.Extension == ".sql");
return(files.Select(file => new FaustMigrationScript
{
ReleaseNumber = int.Parse(file.Directory.Name),
ScriptName = file.Name,
FilePath = file.FullName,
Successful = null,
Commands = GetSqlCommands(file),
})
.Where(script => UnityCache.Resolve <IFaustMigrationsHistoryAccessor>()
.FindMany(new FaustMigrationHistory
{
ReleaseNumber = script.ReleaseNumber,
ScriptName = script.ScriptName,
Committed = true,
}, userContext).Length == 0)
.OrderBy(s => GetScriptOrdinal(s.ScriptName))
.ToArray());
}
public void RunMigration(string databaseName)
{
Logger.Log(string.Format("FaustManager.RunMigration: Running Migrations for database {0}.", databaseName), TraceEventType.Verbose);
Console.WriteLine("##teamcity[message text='FAUSTing Migrations']");
UserContext userContext = UserContext.GetUserContext(databaseName);
UnityCache.Resolve <IFaustMigrationsHistoryAccessor>().Initialize(userContext);
List <DirectoryInfo> releaseDirs = Directory.GetDirectories(ConfigurationManager.AppSettings["MigrationsDirectory"] + databaseName)
.Select(dir => new DirectoryInfo(dir))
.Where(dir => int.Parse(dir.Name) > 0)
.OrderBy(dir => int.Parse(dir.Name))
.ToList();
if (ConfigurationManager.AppSettings["RunDebugMigrations"] == "true")
{
List <DirectoryInfo> holdingDirs = Directory.GetDirectories(ConfigurationManager.AppSettings["MigrationsDirectory"] + databaseName)
.Select(dir => new DirectoryInfo(dir))
.Where(dir => int.Parse(dir.Name) < 0)
.OrderByDescending(dir => int.Parse(dir.Name))
.ToList();
holdingDirs.ForEach(d => releaseDirs.Add(d));
UnityCache.Resolve <IFaustMigrationsHistoryAccessor>().DeleteDebugEntries(userContext);
}
foreach (DirectoryInfo release in releaseDirs)
{
FaustMigrationScript[] scripts = UnityCache.Resolve <IFaustEngine>().GetReleaseMigrationScripts(release, userContext);
List <FaustMigrationHistory> migrationHistories = new List <FaustMigrationHistory>();
TransactionScopeOption scopeOption = TransactionScopeOption.Required;
if (release.EnumerateFiles().Any(file => file.Name == "no.transaction"))
{
scopeOption = TransactionScopeOption.Suppress;
}
TimeSpan desiredTimeout = TimeSpan.FromSeconds(int.Parse(ConfigurationManager.AppSettings["DefaultCommandTimeoutSecondsOverride"]));
Settings.OverrideTransactionManagerMaximumTimeout(desiredTimeout);
using (TransactionScope releaseScope = new TransactionScope(scopeOption, new TransactionOptions {
IsolationLevel = IsolationLevel.ReadCommitted
}))
{
foreach (FaustMigrationScript script in scripts)
{
FaustMigrationHistory migrationHistory = UnityCache.Resolve <IFaustEngine>().RunMigrationScript(script, userContext);
migrationHistories.Add(migrationHistory);
if (!migrationHistory.Successful ?? false)
{
releaseScope.Dispose();
migrationHistories.ForEach(m => m.Committed = false);
Console.WriteLine(string.Format("##teamcity[message text='{0}' errorDetails='' status='ERROR']", migrationHistory.Log));
Console.WriteLine("##teamcity[buildProblem description='FAUST Failed. See build log for details.']");
Logger.Log(string.Format("FaustManager.RunMigration: {0}", migrationHistory.Log), TraceEventType.Error);
break;
}
}
if (Transaction.Current != null)
{
releaseScope.Complete();
Console.WriteLine("##teamcity[message text='FAUSTing completed without errors.']");
}
UnityCache.Resolve <IFaustEngine>().SaveMigrationsHistory(migrationHistories.ToArray(), userContext);
}
}
}
public ICollection <Attendee> GetAllAttendees(UserContext uc)
{
return(UnityCache.ResolveDefault <IRegistrationAccessor>().GetAllAttendees(uc));
}
ICollection <Registration> IRegistrationManager.ProcessRegistration(UserContext userContext, ICollection <Attendee> attendees)
{
ICollection <Attendee> CheckedAttendees = UnityCache.ResolveDefault <IRegistrationEngine>().ProcessAttendees(userContext, attendees);
return(UnityCache.ResolveDefault <IRegistrationAccessor>().AddRegistration(userContext, CheckedAttendees));
}
