public static int Main(string[] args)
{
var connectionString = ConnectionStringFactory.GetConnectionString(args);
var isDryRun = args.Contains("dryRun");
var preDeployResult = PerformUpgrade(connectionString, EnvironmentFilter.GetPreDeployFilter(args), isDryRun);
if (!preDeployResult.Successful)
{
return(ResultReporter.ReportResult(preDeployResult));
}
ResultReporter.ReportResult(preDeployResult);
var result = PerformUpgrade(connectionString, EnvironmentFilter.GetFilter(args), isDryRun);
if (!result.Successful)
{
return(ResultReporter.ReportResult(result));
}
ResultReporter.ReportResult(result);
var postDeployResult = PerformUpgrade(connectionString, EnvironmentFilter.GetPostDeployFilter(args), isDryRun);
return(ResultReporter.ReportResult(postDeployResult));
}
public void UpdateEnvironmentTest()
{
var environment = CreateEnvironment(EnvironmentName, null);
ResetInstance();
var environmentNew = Instance.Get.EnvironmentByID(environment.ID);
Assert.AreEqual(EnvironmentName, environmentNew.Name);
Assert.AreEqual(environment, environmentNew);
environment.Name = EnvironmentNameUpdated;
environment.Save();
var filter = new EnvironmentFilter();
filter.Name.Add(EnvironmentNameUpdated);
filter.Project.Add(SandboxProject);
ResetInstance();
var environments = new List <Environment>(Instance.Get.Environments(filter));
Assert.AreEqual(EnvironmentNameUpdated, environments[0].Name);
CollectionAssert.Contains(environments, environment);
}
public void Script_is_included_when_parameters_match(bool expectedToRun, string scriptFile, params string[] args)
{
// Arrange
var filter = EnvironmentFilter.GetFilter(args);
// Act
var actual = filter.Invoke(scriptFile);
// Assert
actual.Should().Be(expectedToRun);
}
public static int Main(string[] args)
{
var connectionString = ConnectionStringFactory.GetConnectionString(args);
var filter = EnvironmentFilter.GetFilter(args);
var isDryRun = args.Contains("dryRun");
var upgrader = UpgradeFactory.GetUpgradeEngine(connectionString, filter, isDryRun);
var result = upgrader.PerformUpgrade();
return(ResultReporter.ReportResult(result));
}
public void CreateEnvironmentTest()
{
var environment = CreateEnvironment(EnvironmentName, null);
var filter = new EnvironmentFilter();
filter.Name.Add(EnvironmentName);
ResetInstance();
var environments = new List <Environment>(Instance.Get.Environments(filter));
CollectionAssert.Contains(environments, environment);
Assert.AreEqual(EnvironmentName, environments[0].Name);
}
internal Environment GetEnvironment()
{
const string name = "Testing env abv123";
var filter = new EnvironmentFilter();
filter.Name.Add(name);
var env = Instance.Get.Environments(filter);
if (env.Count == 0)
{
return(CreateEnvironment(name, null));
}
var environments = new List <Environment>(env);
return(environments[0]);
}
public void GetEnvironmentByName()
{
var environment = CreateEnvironment(EnvironmentName);
var filter = new EnvironmentFilter();
filter.Name.Add(EnvironmentName);
var environments = Instance.Get.Environments(filter);
CollectionAssert.Contains(environments, environment);
filter = new EnvironmentFilter();
filter.Name.Add("WrongName");
environments = Instance.Get.Environments(filter);
Assert.AreEqual(0, environments.Count);
}
public async Task <Environment[]> GetByFilter(EnvironmentFilter filter)
{
if (filter.LoadAll.GetValueOrDefault())
{
var environments = await environmentRepository.FindByIds(Enumerable.Empty <int>());
return(mapper.Map <Environment[]>(environments));
}
if (filter.Ids.Any())
{
var environments = await environmentRepository.FindByIds(filter.Ids);
return(mapper.Map <Environment[]>(environments));
}
return(new Environment[0]);
}
public void Scripts_are_included_when_parameter_is_added(int expectedNumberOfScriptsIncluded, params string[] args)
{
// Arrange
var filter = EnvironmentFilter.GetFilter(args);
var scripts = new[]
{
"Energinet.DataHub.MarketData.ApplyDBMigrationsApp.Scripts.Model.Script 1.sql",
"Energinet.DataHub.MarketData.ApplyDBMigrationsApp.Scripts.Seed.Script 2.sql",
"Energinet.DataHub.MarketData.ApplyDBMigrationsApp.Scripts.Test.Script 3.sql",
};
// Act
var actualNumberOfScriptsIncluded = scripts.Select(script => filter.Invoke(script))
.Where(filtered => filtered)
.ToList();
// Assert
actualNumberOfScriptsIncluded.Should().HaveCount(expectedNumberOfScriptsIncluded);
}
public void GetEnvironmentWithSpecificProjectTest()
{
var project2 = EntityFactory.Create(() => Instance.Create.Project("other", SandboxProject.ParentProject, DateTime.Now, SandboxSchedule));
var environment = CreateEnvironment(EnvironmentName);
var filter = new EnvironmentFilter();
filter.Project.Add(SandboxProject);
var environments = Instance.Get.Environments(filter);
CollectionAssert.Contains(environments, environment);
filter = new EnvironmentFilter();
filter.Project.Add(project2);
environments = Instance.Get.Environments(filter);
Assert.AreEqual(0, environments.Count);
}
public void GetEnvironmentByID()
{
var environment = CreateEnvironment(EnvironmentName);
var displayId = environment.DisplayID;
var filter = new EnvironmentFilter();
filter.DisplayID.Add(displayId);
var environments = Instance.Get.Environments(filter);
Assert.AreEqual(1, environments.Count);
CollectionAssert.Contains(environments, environment);
filter = new EnvironmentFilter();
filter.DisplayID.Add("WrongNumber");
environments = Instance.Get.Environments(filter);
Assert.AreEqual(0, environments.Count);
}
public void CreateEnvironmentWithAttributesTest()
{
const string newName = "AnotherName";
var newProject = EntityFactory.CreateProject("new project", SandboxProject, null);
var attributes = new Dictionary <string, object> {
{ "Name", newName },
{ "Scope", newProject.ID.Token }
};
var environment = CreateEnvironment(EnvironmentName, attributes);
ResetInstance();
var filter = new EnvironmentFilter();
filter.Name.Add(newName);
filter.Project.Add(newProject);
var environments = new List <Environment>(Instance.Get.Environments(filter));
CollectionAssert.Contains(environments, environment);
Assert.AreEqual(newProject, environments[0].Project);
Assert.AreEqual(newName, environments[0].Name);
}
/// <summary>
/// Get Environment filtered by the criteria specified in the passed in filter.
/// </summary>
/// <param name="filter"></param>
/// <returns></returns>
public ICollection <Environment> Environments(EnvironmentFilter filter)
{
return(Get <Environment>(filter ?? new EnvironmentFilter()));
}
