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))); }