public void Should_Set_The_Error_Handler()
{
// Given
var task = new ActionTask("task");
var builder = new CakeTaskBuilder <ActionTask>(task);
// When
builder.OnError(exception => { });
// Then
Assert.NotNull(builder.Task.ErrorHandler);
}
public void Should_Add_Action_To_Task()
{
// Given
var task = new ActionTask("task");
var builder = new CakeTaskBuilder <ActionTask>(task);
// When
builder.Does(c => { });
// Then
Assert.Equal(1, task.Actions.Count);
}
public void Should_Add_Dependency_To_Task()
{
// Given
var task = new ActionTask("task");
var builder = new CakeTaskBuilder <ActionTask>(task);
// When
builder.IsDependentOn("other");
// Then
Assert.Equal(1, task.Dependencies.Count);
}
public void Should_Throw_If_Action_Is_Null()
{
// Given
var task = new ActionTask("task");
var builder = new CakeTaskBuilder <ActionTask>(task);
// When
var result = Record.Exception(() => builder.Does((Action)null));
// Then
AssertEx.IsArgumentNullException(result, "action");
}
public void Should_Add_Criteria_To_Task()
{
// Given
var task = new ActionTask("task");
var builder = new CakeTaskBuilder <ActionTask>(task);
// When
builder.WithCriteria(context => true);
// Then
Assert.Equal(1, task.Criterias.Count);
}
public void Should_Add_Dependee_To_Task()
{
// Given
var task = new CakeTask("task");
var builder = new CakeTaskBuilder(task);
// When
builder.IsDependeeOf("other");
// Then
Assert.Single(task.Dependees);
Assert.Equal("other", task.Dependees[0].Name);
}
public void Should_Add_Message_To_Criteria_If_Specified()
{
// Given
var task = new CakeTask("task");
var builder = new CakeTaskBuilder(task);
// When
builder.WithCriteria(context => true, "Foo");
// Then
Assert.Single(task.Criterias);
Assert.Equal("Foo", task.Criterias[0].Message);
}
public void Should_Throw_If_OtherBuilder_Is_Null()
{
// Given
var parentTask = new ActionTask("parent");
var builder = new CakeTaskBuilder <ActionTask>(parentTask);
CakeTaskBuilder <ActionTask> childTaskBuilder = null;
// When
var result = Record.Exception(() => builder.IsDependentOn(childTaskBuilder));
// Then
Assert.IsArgumentNullException(result, "other");
}
public void Should_Throw_If_Builder_Is_Null()
{
// Given
var childTask = new ActionTask("child");
CakeTaskBuilder <ActionTask> builder = null;
var childTaskBuilder = new CakeTaskBuilder <ActionTask>(childTask);
// When
var result = Record.Exception(() => builder.IsDependentOn(childTaskBuilder));
// Then
AssertEx.IsArgumentNullException(result, "builder");
}
public void Should_Throw_If_Action_Is_Null()
{
// Given
var task = new CakeTask("task");
var builder = new CakeTaskBuilder(task);
// When
var result = Record.Exception(() =>
CakeTaskBuilderExtensions.DoesForEach(builder, new[] { 1, 2, 3 }, (Action <int, ICakeContext>)null));
// Then
AssertEx.IsArgumentNullException(result, "action");
}
public async Task Should_Throw_On_First_Failed_Action()
{
// Given
var task = new CakeTask("task");
var builder = new CakeTaskBuilder(task);
var context = new CakeContextFixture().CreateContext();
// When
CakeTaskBuilderExtensions.DoesForEach <string, int>(builder, () => new[] { 1, 2, 3 }, (data, item) => throw new NotImplementedException());
var result = await Record.ExceptionAsync(() => builder.Target.Execute(context));
// Then
Assert.IsType <NotImplementedException>(result);
}
public void Should_Add_Dependency_To_Task()
{
// Given
var parentTask = new CakeTask("parent");
var childTask = new CakeTask("child");
var builder = new CakeTaskBuilder(parentTask);
var cakeTaskBuilder = new CakeTaskBuilder(childTask);
// When
builder.IsDependentOn(cakeTaskBuilder);
// Then
Assert.Single(parentTask.Dependencies);
}
public void Should_Add_Dependency_To_Task()
{
// Given
var parentTask = new ActionTask("parent");
var childTask = new ActionTask("child");
var builder = new CakeTaskBuilder <ActionTask>(parentTask);
var cakeTaskBuilder = new CakeTaskBuilder <ActionTask>(childTask);
// When
builder.IsDependentOn(cakeTaskBuilder);
// Then
Assert.Equal(1, parentTask.Dependencies.Count);
}
private void Should_Throw_If_Action_Is_Null()
{
// Given
var task = new ActionTask("task");
var builder = new CakeTaskBuilder <ActionTask>(task);
// When
var exception = Record.Exception(() => builder.Does((Action)null));
// Then
Assert.IsType <ArgumentNullException>(exception);
Assert.Equal("action", ((ArgumentNullException)exception).ParamName);
}
public void Should_Throw_On_First_Failed_Action()
{
// Given
var task = new ActionTask("task");
var builder = new CakeTaskBuilder <ActionTask>(task);
var context = new CakeContextFixture().CreateContext();
// When
CakeTaskBuilderExtensions.DoesForEach(builder, () => new[] { "a", "b", "c" }, (item, c) => throw new NotImplementedException());
var result = Record.Exception(() => builder.Task.Execute(context));
// Then
Assert.IsType <NotImplementedException>(result);
}
/// <summary>
/// Creates an actual Cake task from the internal <see cref="RegisteredTask"/> structure.
/// </summary>
private void RegisterPluginTasks()
{
foreach (RegisteredTask registeredTask in _registeredTasks)
{
CakeTaskBuilder builder = RegisterTask(registeredTask.Name)
.Description(registeredTask.Description);
if (registeredTask.ContinueOnError)
{
builder.ContinueOnError();
}
if (registeredTask.AttributeType == typeof(TaskAttribute) && registeredTask.RequiresConfig)
{
builder.IsDependentOn(TaskNames.Config);
}
ParameterInfo[] parameters = registeredTask.Method.GetParameters();
switch (parameters.Length)
{
case 2:
var action2 = (Action <ICakeContext, TaskConfig>)registeredTask.Method.CreateDelegate(
typeof(Action <ICakeContext, TaskConfig>));
builder.Does(action2);
break;
case 1:
if (parameters[0].ParameterType == typeof(TaskConfig))
{
Action <ICakeContext, TaskConfig> action1 = (_, cfg) =>
{
registeredTask.Method.Invoke(obj: null, new object[] { cfg });
};
builder.Does(action1);
}
else
{
var action1 = (Action <ICakeContext>)registeredTask.Method.CreateDelegate(typeof(Action <ICakeContext>));
builder.Does(action1);
}
break;
default:
var action = (Action)registeredTask.Method.CreateDelegate(typeof(Action));
builder.Does(action);
break;
}
}
}
public void Should_Add_Dependency_To_Task_With_Correct_Name()
{
// Given
var parentTask = new ActionTask("parent");
var childTask = new ActionTask("child");
var builder = new CakeTaskBuilder <ActionTask>(parentTask);
var childTaskBuilder = new CakeTaskBuilder <ActionTask>(childTask);
// When
builder.IsDependentOn(childTaskBuilder);
// Then
Assert.Equal(parentTask.Dependencies[0], childTaskBuilder.Task.Name);
}
public void Should_Only_Aggregate_Exceptions_When_There_Are_Many()
{
// Given
var task = new ActionTask("task");
var builder = new CakeTaskBuilder <ActionTask>(task);
var context = new CakeContextFixture().CreateContext();
// When
builder.Does(() => throw new NotImplementedException());
builder.DeferOnError();
var result = Record.Exception(() => builder.Task.Execute(context));
// Then
Assert.IsType <NotImplementedException>(result);
}
public void Should_Throw_On_First_Failed_Action()
{
// Given
var task = new ActionTask("task");
var builder = new CakeTaskBuilder <ActionTask>(task);
var context = new CakeContextFixture().CreateContext();
// When
builder.Does(() => throw new NotImplementedException());
builder.Does(() => throw new NotSupportedException());
builder.Does(() => throw new OutOfMemoryException());
var result = Record.Exception(() => builder.Task.Execute(context));
// Then
Assert.IsType <NotImplementedException>(result);
}
/// <summary>
/// A quick error function that will invoke errors using the event
/// </summary>
/// <param name="builder">The CakeTaskBuilder being extended</param>
/// <param name="continueOnError">Continue On error allows you to continue building if you don't want to report</param>
public static void QuickError(this CakeTaskBuilder builder, bool continueOnError = false)
{
if (continueOnError)
{
builder.ReportError((exception) => {
_exceptionEvent?.Invoke(builder.Task.Name, exception);
});
}
else
{
builder.OnError((exception) => {
_exceptionEvent?.Invoke(builder.Task.Name, exception);
throw exception;
});
}
}
private void GenerateTasks(string taskName, IEnumerable <Target> targets)
{
CakeTaskBuilder <ActionTask> buildTask = _parameters.Context.Task($"build-{taskName}");
CakeTaskBuilder <ActionTask> releaseTask = _parameters.Context.Task($"release-{taskName}");
CakeTaskBuilder <ActionTask> deployTask = _parameters.Context.Task($"deploy-{taskName}");
foreach (Target target in targets)
{
buildTask.IsDependentOn(target.BuildTaskName);
releaseTask.IsDependentOn(target.ReleaseTaskName);
deployTask.IsDependentOn(target.DeployTaskName);
}
buildTask.Does(() => { });
releaseTask.Does(() => { });
deployTask.Does(() => { });
}
public void TaskHelper_AddTaskDependency_NoBuilderTask()
{
var context = this.GetMoqContext(new Dictionary <string, bool>(), new Dictionary <string, string>());
SingletonFactory.Context = context;
var settings = SingletonFactory.GetHelperSettings();
settings.TaskTargetFunc = taskName => { return(new CakeTaskBuilder <ActionTask>(new ActionTask(taskName))); };
var taskHelper = SingletonFactory.GetTaskHelper();
Assert.IsNotNull(taskHelper);
CakeTaskBuilder <ActionTask> firstTask = null;
Assert.ThrowsException <ArgumentNullException>(() => taskHelper.AddTaskDependency(firstTask, "test"));
}
/// <summary>
/// Configures the dependency, criteria and error handling for a dotnet-lib recipe task
/// </summary>
/// <param name="builder">Cake task builder</param>
/// <param name="lib"><see cref="DotNetLib"/> recipe configuration</param>
/// <param name="dependentOn">Dependent task builder</param>
/// <param name="dependee">Dependee task builder</param>
/// <returns></returns>
public static CakeTaskBuilder ConfigTaskFor(
this CakeTaskBuilder builder,
DotNetLib lib,
CakeTaskBuilder dependentOn,
CakeTaskBuilder dependee)
{
if (dependentOn is null)
{
throw new ArgumentNullException("Dependent task is null");
}
if (dependee is null)
{
throw new ArgumentNullException("Dependee task is null");
}
builder.ConfigTaskFor(lib, dependentOn.Task.Name, dependee.Task.Name);
return(builder);
}
public void Should_Support_Defered_Item_And_Context_Action()
{
// Given
var task = new ActionTask("task");
var builder = new CakeTaskBuilder <ActionTask>(task);
var context = new CakeContextFixture().CreateContext();
// When
CakeTaskBuilderExtensions.DoesForEach(builder, () => new[] { "a", "b", "c" }, (item, c) => { });
// Then
Assert.Empty(builder.Task.Actions);
Assert.Single(builder.Task.DelayedActions);
// When
builder.Task.Execute(context);
// Then
Assert.Empty(builder.Task.DelayedActions);
Assert.Equal(3, builder.Task.Actions.Count);
}
public void Should_Defer_Delegate_Items_Until_Execution()
{
// Given
var task = new ActionTask("task");
var builder = new CakeTaskBuilder <ActionTask>(task);
var context = new CakeContextFixture().CreateContext();
// When
CakeTaskBuilderExtensions.DoesForEach(builder, () => new[] { "a", "b", "c" }, (item) => { });
// Then
Assert.Equal(0, builder.Task.Actions.Count);
Assert.Equal(1, builder.Task.DelayedActions.Count);
// When
builder.Task.Execute(context);
// Then
Assert.Equal(0, builder.Task.DelayedActions.Count);
Assert.Equal(3, builder.Task.Actions.Count);
}
public async Task Should_Add_Actions_To_Task_After_Execution()
{
// Given
var task = new CakeTask("task");
var builder = new CakeTaskBuilder(task);
var context = new CakeContextFixture().CreateContext();
// When
CakeTaskBuilderExtensions.DoesForEach(builder, () => new[] { "a", "b", "c" }, item => { });
// Then
Assert.Empty(builder.Target.Actions);
Assert.Single(builder.Target.DelayedActions);
// When
await builder.Target.Execute(context);
// Then
Assert.Empty(builder.Target.DelayedActions);
Assert.Equal(3, builder.Target.Actions.Count);
}
public void Should_Aggregate_Exceptions_From_Actions()
{
// Given
var task = new ActionTask("task");
var builder = new CakeTaskBuilder <ActionTask>(task);
var context = new CakeContextFixture().CreateContext();
// When
builder.Does(() => throw new NotImplementedException());
builder.Does(() => throw new NotSupportedException());
builder.Does(() => throw new OutOfMemoryException());
builder.DeferOnError();
var result = Record.Exception(() => builder.Task.Execute(context));
// Then
Assert.IsType <AggregateException>(result);
var ex = result as AggregateException;
Assert.Contains(ex.InnerExceptions, x => x.GetType() == typeof(NotImplementedException));
Assert.Contains(ex.InnerExceptions, x => x.GetType() == typeof(NotSupportedException));
Assert.Contains(ex.InnerExceptions, x => x.GetType() == typeof(OutOfMemoryException));
}
/// <summary>
/// Adds dependency between tasks
/// </summary>
/// <param name="helper">TaskHelper</param>
/// <param name="task">Task</param>
/// <param name="dependentTaskName">Task name</param>
public static void AddTaskDependency(
this IHelperTaskHandler helper,
CakeTaskBuilder <ActionTask> task,
string dependentTaskName)
{
if (task == null)
{
throw new ArgumentNullException(nameof(task));
}
if (string.IsNullOrWhiteSpace(dependentTaskName))
{
throw new ArgumentNullException(nameof(dependentTaskName));
}
if (task.Task.Dependencies.Any(t => t == dependentTaskName))
{
return;
}
task.IsDependentOn(dependentTaskName);
}
/// <summary>
/// Registers built-in utility tasks that can be used to display various details about the
/// Cake tasks, such as listing environments, tasks and configurations.
/// </summary>
private void RegisterBuiltInTasks()
{
// The Default task lists all available public tasks (tasks not prefixed with underscore).
void RegisterDefaultTask()
{
RegisterTask("Default")
.Does(ctx =>
{
ctx.Log.Information("Task List");
ctx.Log.Information("---------");
foreach (ICakeTaskInfo task in Tasks)
{
if (task.Name.StartsWith("_"))
{
continue;
}
if (task.Name.Equals("Default", StringComparison.OrdinalIgnoreCase))
{
continue;
}
ctx.Log.Information(task.Name);
if (!string.IsNullOrWhiteSpace(task.Description))
{
ctx.Log.Information($" {task.Description}");
}
}
});
}
// The ListEnvs task goes through all available tasks and identifies all the available
// environments.
void RegisterListEnvsTask()
{
RegisterTask(TaskNames.ListEnvs)
.Description("Lists all available environments.")
.Does(ctx =>
{
IList <string> environments = _registeredTasks
.Select(task => task.CiSystem)
.Distinct(StringComparer.OrdinalIgnoreCase)
.OrderBy(env => env)
.ToList();
if (environments.Count > 0)
{
ctx.Log.Information("Available Environments");
ctx.Log.Information("----------------------");
foreach (string env in environments)
{
ctx.Log.Information(env);
}
}
else
{
ctx.Log.Information("No environments found!");
}
});
}
// The ListConfigs task lists the final values of all configuration values. It depends on
// the _Config task, as it needs to execute all the config tasks first, before it can get
// the final vakues.
void RegisterListConfigsTask()
{
CakeTaskBuilder listConfigsTask = RegisterTask(TaskNames.ListConfigs)
.Description("Lists all available configurations.");
IEnumerable <RegisteredTask> configTasks = GetTasksForCiEnvironment()
.Where(rt => rt.AttributeType == typeof(ConfigAttribute));
foreach (RegisteredTask configTask in configTasks)
{
listConfigsTask = listConfigsTask.IsDependentOn(configTask.Name);
}
listConfigsTask.IsDependentOn(TaskNames.Config);
}
// The ListTasks tasks lists all tasks including private tasks (which are prefixed with an
// underscore).
void RegisterListTasksTask()
{
RegisterTask(TaskNames.ListTasks)
.Description("Lists all tasks including private tasks.")
.Does(ctx =>
{
ctx.Log.Information("Task List");
ctx.Log.Information("---------");
foreach (ICakeTaskInfo task in Tasks)
{
if (task.Name.Equals("Default", StringComparison.OrdinalIgnoreCase))
{
continue;
}
ctx.Log.Information(task.Name);
if (!string.IsNullOrWhiteSpace(task.Description))
{
ctx.Log.Information($" {task.Description}");
}
}
});
}
RegisterDefaultTask();
RegisterListEnvsTask();
RegisterListConfigsTask();
RegisterListTasksTask();
}
public static CakeTaskBuilder DescriptionFromArguments <T>(this CakeTaskBuilder builder, string taskDescription)
{
return(builder.Description(ArgumentBinder.GetDescription <T>(taskDescription)));
}
