private void when_validate_a_snapshot_step()
{
act = () => { _actualResult = _validator.Validate(_snapshotStep, "Environment01"); };
context["the step already exists and successfully deployed"] = () =>
{
before = () => { _snapshotStep = new SnapshotStep {
ProjectId = "Project01.1", ReleaseId = "Release01.1"
}; };
it["should be resolved as valid"] = () => { _actualResult.should_be_false(); };
};
context["the step already exists and failed to deploy"] = () =>
{
before = () => { _snapshotStep = new SnapshotStep {
ProjectId = "Project01.2", ReleaseId = "Release01.2"
}; };
it["should be resolved as invalid"] = () => { _actualResult.should_be_true(); };
};
context["the step does not exist"] = () =>
{
before = () => { _snapshotStep = new SnapshotStep {
ProjectId = "SomeName", ReleaseId = "SomeRelease"
}; };
it["should be resolved as invalid"] = () => { _actualResult.should_be_true(); };
};
}
private void when_create_a_task()
{
before = () =>
{
_snapshotStep = new SnapshotStep();
_expectedTaskResource = new TaskResource {
Id = "Task01"
};
var deploymentResource = new DeploymentResource {
TaskId = _expectedTaskResource.Id
};
A.CallTo(() => _deployments.Create(A <DeploymentResource> ._)).Returns(deploymentResource);
A.CallTo(() => _tasks.Get(A <string> ._)).Returns(_expectedTaskResource);
};
act = () => { _actualTaskResource = _factory.Create(_snapshotStep, "Environment01"); };
it["should return a task"] = () => { _actualTaskResource.should_be(_expectedTaskResource); };
it["should create a deployment"] = () =>
{
A.CallTo(() => _deployments.Create(A <DeploymentResource> .That.Matches(x =>
x.ReleaseId == _snapshotStep.ReleaseId &&
x.ProjectId == _snapshotStep.ProjectId &&
x.EnvironmentId == "Environment01"
))).MustHaveHappened();
};
}
private void before_each()
{
_environmentId = "EnvironmentId01";
_taskFactory = A.Fake <ICreateTaskResources>(x => x.Strict());
_taskWaiter = A.Fake <IWaitForExecutedTaskResources>(x => x.Strict());
_deployer = new SnapshotStepDeployer(_taskFactory, _taskWaiter);
_step = new SnapshotStep();
}
public bool Validate(SnapshotStep step, string environmentId)
{
var itemResources = _repository.Dashboards.GetDashboard().Items;
var deployed = itemResources.Any(
x =>
x.EnvironmentId == environmentId &&
x.ProjectId == step.ProjectId &&
x.ReleaseId == step.ReleaseId &&
x.State == TaskState.Success);
return(!deployed);
}
public TaskResource Create(SnapshotStep snapshotStep, string environmentId)
{
Log.Info($"Creating Delpoyment task.");
var deploymentResource = new DeploymentResource
{
ReleaseId = snapshotStep.ReleaseId,
ProjectId = snapshotStep.ProjectId,
EnvironmentId = environmentId
};
deploymentResource = _repository.Deployments.Create(deploymentResource);
return(_repository.Tasks.Get(deploymentResource.TaskId));
}
public void Deploy(SnapshotStep step, string environmentId)
{
Log.Info($"Deployment step {step.Index} project {step.ProjectName} version {step.ReleaseVersion}. Started.");
var task = _taskResources.Create(step, environmentId);
task = _executedTaskResources.Wait(task);
Log.Debug("Validating deployment task state..");
if (task.State != TaskState.Success)
{
var message = $"Deployment task for project {step.ProjectName} finished with {task.State} state.";
throw new IndexOutOfRangeException(message);
}
Log.Info($"Deployment step {step.Index} project {step.ProjectName} version {step.ReleaseVersion}. Finished.");
}
private void when_deploy_a_snapshot()
{
act = () => _deployer.Deploy(_snapshot);
context["with a step"] = () =>
{
before = () =>
{
_snapshotStep1 = new SnapshotStep
{
ProjectId = "Project01",
ReleaseId = "Release01"
};
_snapshot.Steps = new[] { _snapshotStep1 };
A.CallTo(() => _stepDeployer.Deploy(_snapshotStep1, _environment.Id)).DoesNothing();
A.CallTo(() => _validator.Validate(_snapshotStep1, _environment.Id)).Returns(true);
};
it["should deploy the step"] =
() =>
{
var step = _snapshotStep1;
A.CallTo(() => _stepDeployer.Deploy(step, A <string> ._)).MustHaveHappened();
};
it["should deploy to a configured environment"] = () =>
{
var id = _environment.Id;
A.CallTo(() => _stepDeployer.Deploy(A <SnapshotStep> ._, id)).MustHaveHappened();
};
};
context["with two steps"] =
() =>
{
before = () =>
{
_snapshotStep1 = new SnapshotStep
{
Index = 1,
ProjectId = "Project01",
ReleaseId = "Release01"
};
_snapshotStep2 = new SnapshotStep
{
Index = 2,
ProjectId = "Project02",
ReleaseId = "Release02"
};
_snapshot.Steps = new[] { _snapshotStep2, _snapshotStep1 };
A.CallTo(() => _validator.Validate(A <SnapshotStep> ._, _environment.Id)).Returns(true);
A.CallTo(() => _stepDeployer.Deploy(A <SnapshotStep> ._, _environment.Id)).DoesNothing();
};
it["should deploy in correct order"] = () =>
{
var id = _environment.Id;
A.CallTo(() => _stepDeployer.Deploy(_snapshotStep1, id)).MustHaveHappened()
.Then(A.CallTo(() => _stepDeployer.Deploy(_snapshotStep2, id)).MustHaveHappened());
};
};
context["with a step is not valid"] =
() =>
{
before = () =>
{
_snapshotStep1 = new SnapshotStep
{
Index = 1,
ProjectId = "Project01",
ReleaseId = "Release01"
};
_snapshot.Steps = new[] { _snapshotStep1 };
A.CallTo(() => _validator.Validate(A <SnapshotStep> ._, _environment.Id)).Returns(false);
A.CallTo(() => _stepDeployer.Deploy(A <SnapshotStep> ._, _environment.Id)).DoesNothing();
};
it["should skip the step"] =
() =>
{
A.CallTo(() => _stepDeployer.Deploy(_snapshotStep1, _environment.Id)).MustNotHaveHappened();
};
};
}
