public void Should_Print_Delegated_Tasks_When_Verbosity_Suffices(Verbosity verbosity)
{
// Given
var log = Substitute.For <ICakeLog>();
log.Verbosity.Returns(verbosity);
var context = Substitute.For <ICakeContext>();
context.Log.Returns(log);
var console = new FakeConsole();
var report = new CakeReport();
var taskName = "TaskName";
var tasknameThatWasDelegated = "TaskName-That-Was-Delegated";
var duration = TimeSpan.FromSeconds(10);
var durationDelegatedTask = TimeSpan.FromSeconds(5);
report.Add(taskName, duration);
report.AddDelegated(tasknameThatWasDelegated, durationDelegatedTask);
var printer = new CakeReportPrinter(console, context);
// When
printer.Write(report);
// Then
var expected = $"{tasknameThatWasDelegated, -30}{durationDelegatedTask, -20}";
Assert.Contains(console.Messages, s => s == expected);
}
public void Write(CakeReport report)
{
if (report == null)
{
throw new ArgumentNullException("report");
}
try
{
_console.ForegroundColor = ConsoleColor.Green;
_console.WriteLine();
_console.WriteLine("{0,-30}{1,-20}", "Task", "Duration");
_console.WriteLine(new string('-', 50));
foreach (var item in report)
{
var name = item.Key;
var time = item.Value.ToString("c", CultureInfo.InvariantCulture);
_console.WriteLine("{0,-30}{1,-20}", name, time);
}
}
finally
{
_console.ResetColor();
}
}
public void Should_Not_Print_Delegated_Tasks_When_Verbosity_Does_Not_Suffice(Verbosity verbosity)
{
// Given
var log = Substitute.For <ICakeLog>();
log.Verbosity.Returns(verbosity);
var context = Substitute.For <ICakeContext>();
context.Log.Returns(log);
var console = new FakeConsole();
var report = new CakeReport();
string taskName = "TaskName";
string tasknameThatWasDelegated = "TaskName-That-Was-Delegated";
TimeSpan duration = TimeSpan.FromSeconds(10);
TimeSpan durationDelegatedTask = TimeSpan.FromSeconds(5);
report.Add(taskName, duration);
report.AddDelegated(tasknameThatWasDelegated, durationDelegatedTask);
var printer = new CakeReportPrinter(console, context);
// When
printer.Write(report);
// Then
string expected = String.Format("{0,-30}{1,-20}", tasknameThatWasDelegated, durationDelegatedTask);
Assert.DoesNotContain(console.Messages, s => s == expected);
}
public void Write(CakeReport report)
{
if (report == null)
{
throw new ArgumentNullException("report");
}
try
{
_console.ForegroundColor = ConsoleColor.Green;
// Write header.
_console.WriteLine();
_console.WriteLine("{0,-30}{1,-20}", "Task", "Duration");
_console.WriteLine(new string('-', 50));
// Write task status.
foreach (var item in report)
{
_console.WriteLine("{0,-30}{1,-20}", item.TaskName, FormatTime(item.Duration));
}
// Write footer.
_console.WriteLine(new string('-', 50));
_console.WriteLine("{0,-30}{1,-20}", "Total:", FormatTime(GetTotalTime(report)));
}
finally
{
_console.ResetColor();
}
}
private void WriteToBuildLog(CakeReport report)
{
var b = _context.MyGet();
var maxTaskNameLength = 29;
foreach (var item in report)
{
if (item.TaskName.Length > maxTaskNameLength)
{
maxTaskNameLength = item.TaskName.Length;
}
}
maxTaskNameLength++;
string lineFormat = "{0,-" + maxTaskNameLength + "}{1,-20}";
foreach (var entry in report)
{
if (ShouldWriteTask(entry))
{
_log.Write(Verbosity.Quiet, LogLevel.Information,
"##myget[message text='{0}' status='NORMAL']", string.Format(lineFormat, entry.TaskName, FormatDuration(entry)));
}
}
// Write footer.
_console.WriteLine(lineFormat, "Total:", FormatTime(GetTotalTime(report)));
}
public void Should_Add_A_New_Task()
{
// Given
var report = new CakeReport();
var taskName = "task";
// When
report.AddSkipped(taskName);
// Then
var firstTask = report.First();
Assert.Equal(taskName, firstTask.TaskName);
Assert.Equal(TimeSpan.Zero, firstTask.Duration);
Assert.Equal(CakeTaskExecutionStatus.Skipped, firstTask.ExecutionStatus);
}
public void Write(CakeReport report)
{
if (report == null)
{
throw new ArgumentNullException("report");
}
try
{
var maxTaskNameLength = 29;
foreach (var item in report)
{
if (item.TaskName.Length > maxTaskNameLength)
{
maxTaskNameLength = item.TaskName.Length;
}
}
maxTaskNameLength++;
string lineFormat = "{0,-" + maxTaskNameLength + "}{1,-20}";
_console.ForegroundColor = ConsoleColor.Green;
// Write header.
_console.WriteLine();
_console.WriteLine(lineFormat, "Task", "Duration");
_console.WriteLine(new string('-', 20 + maxTaskNameLength));
// Write task status.
foreach (var item in report)
{
if (ShouldWriteTask(item))
{
_console.ForegroundColor = GetItemForegroundColor(item);
_console.WriteLine(lineFormat, item.TaskName, FormatDuration(item));
}
}
// Write footer.
_console.ForegroundColor = ConsoleColor.Green;
_console.WriteLine(new string('-', 20 + maxTaskNameLength));
_console.WriteLine(lineFormat, "Total:", FormatTime(GetTotalTime(report)));
}
finally
{
_console.ResetColor();
}
}
public void Should_Add_A_New_Task()
{
// Given
var report = new CakeReport();
var taskName = "task";
var duration = TimeSpan.FromMilliseconds(100);
// When
report.Add("task", duration);
// Then
var firstTask = report.First();
Assert.Equal(taskName, firstTask.TaskName);
Assert.Equal(duration, firstTask.Duration);
Assert.Equal(CakeTaskExecutionStatus.Executed, firstTask.ExecutionStatus);
}
public void Should_Print_Report()
{
// Given
var report = new CakeReport();
report.Add("Target", TimeSpan.FromSeconds(1));
var engine = Substitute.For <ICakeEngine>();
engine.RunTarget("Target").Returns(report);
var printer = Substitute.For <ICakeReportPrinter>();
var host = new BuildScriptHost(engine, printer);
// When
host.RunTarget("Target");
// Then
printer.Received(1).Write(report);
}
public void Should_Add_To_End_Of_Sequence()
{
// Given
var report = new CakeReport();
report.AddSkipped("task 1");
var taskName = "task 2";
// When
report.AddSkipped(taskName);
// Then
var lastTask = report.Last();
Assert.Equal(taskName, lastTask.TaskName);
Assert.Equal(TimeSpan.Zero, lastTask.Duration);
Assert.Equal(CakeTaskExecutionStatus.Skipped, lastTask.ExecutionStatus);
}
public void Should_Default_To_30_Width()
{
// Given
var console = new FakeConsole();
var report = new CakeReport();
string taskName = "TaskName";
TimeSpan duration = TimeSpan.FromSeconds(10);
report.Add(taskName, duration);
var printer = new CakeReportPrinter(console);
// When
printer.Write(report);
// Then
string expected = String.Format("{0,-30}{1,-20}", taskName, duration);
Assert.Contains(console.Messages, s => s == expected);
}
public void Write(CakeReport report)
{
if (report == null)
{
throw new ArgumentNullException("report");
}
try
{
var maxTaskNameLength = 29;
foreach (var item in report)
{
if (item.TaskName.Length > maxTaskNameLength)
{
maxTaskNameLength = item.TaskName.Length;
}
}
maxTaskNameLength++;
string lineFormat = "{0,-" + maxTaskNameLength + "}{1,-20}";
_console.ForegroundColor = ConsoleColor.Green;
// Write header.
_console.WriteLine();
_console.WriteLine(lineFormat, "Task", "Duration");
_console.WriteLine(new string('-', 20 + maxTaskNameLength));
// Write task status.
foreach (var item in report)
{
_console.WriteLine(lineFormat, item.TaskName, FormatTime(item.Duration));
}
// Write footer.
_console.WriteLine(new string('-', 20 + maxTaskNameLength));
_console.WriteLine(lineFormat, "Total:", FormatTime(GetTotalTime(report)));
}
finally
{
_console.ResetColor();
}
}
public void Should_Default_To_30_Width()
{
// Given
var context = Substitute.For <ICakeContext>();
var console = new FakeConsole();
var report = new CakeReport();
var taskName = "TaskName";
var duration = TimeSpan.FromSeconds(10);
report.Add(taskName, duration);
var printer = new CakeReportPrinter(console, context);
// When
printer.Write(report);
// Then
string expected = $"{taskName, -30}{duration, -20}";
Assert.Contains(console.Messages, s => s == expected);
}
public override void Write(CakeReport report)
{
if (report == null)
{
throw new ArgumentNullException(nameof(report));
}
try
{
if (_context.MyGet().IsRunningOnMyGet)
{
WriteToBuildLog(report);
}
WriteToConsole(report);
}
finally
{
_console.ResetColor();
}
}
public void Should_Add_To_End_Of_Sequence()
{
// Given
var report = new CakeReport();
report.Add("task 1", TimeSpan.FromMilliseconds(100));
var taskName = "task";
var duration = TimeSpan.FromMilliseconds(200);
// When
report.Add(taskName, duration);
// Then
var lastTask = report.Last();
Assert.Equal(taskName, lastTask.TaskName);
Assert.Equal(duration, lastTask.Duration);
Assert.Equal(CakeTaskExecutionStatus.Executed, lastTask.ExecutionStatus);
}
public void Should_Print_Report()
{
// Given
var report = new CakeReport();
report.Add("Target", TimeSpan.FromSeconds(1));
var engine = Substitute.For <ICakeEngine>();
var context = Substitute.For <ICakeContext>();
engine.RunTarget(context, Arg.Any <DefaultExecutionStrategy>(), "Target").Returns(report);
var printer = Substitute.For <ICakeReportPrinter>();
var log = Substitute.For <ICakeLog>();
var host = new BuildScriptHost(engine, context, printer, log);
// When
host.RunTarget("Target");
// Then
printer.Received(1).Write(report);
}
public override void Write(CakeReport report)
{
if (report == null)
{
throw new ArgumentNullException(nameof(report));
}
try
{
if (_context.TFBuild().IsRunningOnTFS || _context.TFBuild().IsRunningOnVSTS)
{
WriteToMarkdown(report);
}
WriteToConsole(report);
}
finally
{
_console.ResetColor();
}
}
private void WriteToMarkdown(CakeReport report)
{
var maxTaskNameLength = 29;
foreach (var item in report)
{
if (item.TaskName.Length > maxTaskNameLength)
{
maxTaskNameLength = item.TaskName.Length;
}
}
maxTaskNameLength++;
string lineFormat = "|{0,-" + maxTaskNameLength + "}|{1,20}|";
var sb = new StringBuilder();
sb.AppendLine("");
sb.AppendLine("|Task|Duration|");
sb.AppendLine("|:---|-------:|");
foreach (var item in report)
{
if (ShouldWriteTask(item))
{
sb.AppendLine(string.Format(lineFormat, item.TaskName, FormatDuration(item)));
}
}
sb.AppendLine("");
var b = _context.BuildSystem().AzurePipelines;
FilePath agentWorkPath = b.Environment.Build.ArtifactStagingDirectory + "/tasksummary.md";
var absFilePath = agentWorkPath.MakeAbsolute(_context.Environment);
var file = _context.FileSystem.GetFile(absFilePath);
using (var writer = new StreamWriter(file.OpenWrite()))
{
writer.Write(sb.ToString());
}
_console.WriteLine($"##vso[task.addattachment type=Distributedtask.Core.Summary;name=Cake Build Summary;]{absFilePath.MakeAbsolute(_context.Environment).FullPath}");
}
public bool RunTarget(string target, bool load)
{
this.CurrentTask = target;
bool result;
if (load)
{
IList <string> args = this.GetArgs(target);
result = _Application.Run(args);
}
else
{
CakeReport report = _Host.RunTarget(target);
result = (report != null && !report.IsEmpty);
}
this.CurrentTask = "";
return(result);
}
public void Should_Increase_Width_For_Long_Task_Names()
{
// Given
var console = new FakeConsole();
var report = new CakeReport();
string taskName = "TaskName";
string taskName2 = "Task-Name-That-Has-A-Length-Of-44-Characters";
TimeSpan duration = TimeSpan.FromSeconds(10);
report.Add(taskName, duration);
report.Add(taskName2, duration);
var printer = new CakeReportPrinter(console);
// When
printer.Write(report);
// Then
string expected = String.Format("{0,-45}{1,-20}", taskName, duration);
Assert.Contains(console.Messages, s => s == expected);
}
/// <summary>
/// Writes the specified report to a target.
/// </summary>
/// <param name="report">The report to write.</param>
public override void Write(CakeReport report)
{
if (report == null)
{
throw new ArgumentNullException(nameof(report));
}
try
{
if (_context.AzurePipelines().IsRunningOnAzurePipelines)
{
WriteToMarkdown(report);
}
WriteToConsole(report);
}
finally
{
_console.ResetColor();
}
}
public void Should_Add_To_End_Of_Sequence()
{
// Given
var report = new CakeReport();
report.AddSkipped("task 1");
var taskName = "task 2";
var duration = TimeSpan.FromMilliseconds(100);
// When
report.AddDelegated(taskName, duration);
// Then
var lastTask = report.LastOrDefault();
Assert.NotNull(lastTask);
Assert.Equal(taskName, lastTask.TaskName);
Assert.Equal(duration, lastTask.Duration);
Assert.Equal(CakeTaskExecutionStatus.Delegated, lastTask.ExecutionStatus);
}
private IHelperSettings GetSettings(ICakeContext context)
{
SingletonFactory.Context = context;
var settings = SingletonFactory.GetHelperSettings();
settings.TaskTargetFunc = taskName =>
{
var task = new ActionTask(taskName);
return(new CakeTaskBuilder <ActionTask>(task));
};
settings.RunTargetFunc = targetName =>
{
var report = new CakeReport {
{ targetName, TimeSpan.Zero, CakeTaskExecutionStatus.Executed }
};
return(report);
};
return(settings);
}
public void Should_Increase_Width_For_Long_Task_Names()
{
// Given
var context = Substitute.For <ICakeContext>();
var console = new FakeConsole();
var report = new CakeReport();
var taskName = "TaskName";
var taskName2 = "Task-Name-That-Has-A-Length-Of-44-Characters";
var duration = TimeSpan.FromSeconds(10);
report.Add(taskName, duration);
report.Add(taskName2, duration);
var printer = new CakeReportPrinter(console, context);
// When
printer.Write(report);
// Then
string expected = $"{taskName, -45}{duration, -20}";
Assert.Contains(console.Messages, s => s == expected);
}
public void Should_Print_No_Duration_For_Skipped_Tasks()
{
// Given
var context = Substitute.For <ICakeContext>();
var console = new FakeConsole();
var report = new CakeReport();
string taskName = "TaskName";
string taskNameThatWasSkipped = "TaskName-That-Was-Skipped";
TimeSpan duration = TimeSpan.FromSeconds(10);
report.Add(taskName, duration);
report.AddSkipped(taskNameThatWasSkipped);
var printer = new CakeReportPrinter(console, context);
// When
printer.Write(report);
// Then
string expected = String.Format("{0,-30}{1,-20}", taskNameThatWasSkipped, "Skipped");
Assert.Contains(console.Messages, s => s == expected);
}
/// <summary>
/// Writes the report to the <see cref="IConsole"/>.
/// </summary>
/// <param name="report">The report to write.</param>
protected void WriteToConsole(CakeReport report)
{
var maxTaskNameLength = 29;
foreach (var item in report)
{
if (item.TaskName.Length > maxTaskNameLength)
{
maxTaskNameLength = item.TaskName.Length;
}
}
maxTaskNameLength++;
string lineFormat = "{0,-" + maxTaskNameLength + "}{1,-20}";
_console.ForegroundColor = ConsoleColor.Green;
// Write header.
_console.WriteLine();
_console.WriteLine(lineFormat, "Task", "Duration");
_console.WriteLine(new string('-', 20 + maxTaskNameLength));
// Write task status.
foreach (var item in report)
{
if (ShouldWriteTask(item))
{
_console.ForegroundColor = GetItemForegroundColor(item);
_console.WriteLine(lineFormat, item.TaskName, FormatDuration(item));
}
}
// Write footer.
_console.ForegroundColor = ConsoleColor.Green;
_console.WriteLine(new string('-', 20 + maxTaskNameLength));
_console.WriteLine(lineFormat, "Total:", FormatTime(GetTotalTime(report)));
}
/// <inheritdoc /> public abstract void Write(CakeReport report);
public async Task <CakeReport> RunTargetAsync(ICakeContext context, IExecutionStrategy strategy, string target)
{
if (target == null)
{
throw new ArgumentNullException(nameof(target));
}
if (strategy == null)
{
throw new ArgumentNullException(nameof(strategy));
}
var graph = ParallelGraphBuilder.Build(_tasks);
// Make sure target exist.
if (!graph.Exist(target))
{
const string format = "The target '{0}' was not found.";
throw new CakeException(string.Format(CultureInfo.InvariantCulture, format, target));
}
// This isn't pretty, but we need to keep track of exceptions thrown
// while running a setup action, or a task. We do this since we don't
// want to throw teardown exceptions if an exception was thrown previously.
var exceptionWasThrown = false;
Exception thrownException = null;
try
{
PerformSetup(strategy, context);
var stopWatch = Stopwatch.StartNew();
var report = new CakeReport();
await graph.Traverse(target, async (taskName, cts) =>
{
if (cts.IsCancellationRequested)
{
return;
}
var task = _tasks.FirstOrDefault(_ => _.Name.Equals(taskName, StringComparison.OrdinalIgnoreCase));
Debug.Assert(task != null, "Node should not be null");
var isTarget = task.Name.Equals(target, StringComparison.OrdinalIgnoreCase);
if (ShouldExecuteTask(context, task, isTarget))
{
await ExecuteTaskAsync(context, strategy, cts, task, report).ConfigureAwait(false);
}
else
{
SkipTask(context, strategy, task, report);
}
}).ConfigureAwait(false);
_log.Information($"All tasks completed in {stopWatch.Elapsed}");
return(report);
}
catch (TaskCanceledException)
{
exceptionWasThrown = true;
throw;
}
catch (AggregateException ex)
{
exceptionWasThrown = true;
thrownException = ex.InnerException;
throw;
}
catch (Exception ex)
{
exceptionWasThrown = true;
thrownException = ex;
throw;
}
finally
{
PerformTeardown(strategy, context, exceptionWasThrown, thrownException);
}
}
private void SkipTask(ICakeContext context, IExecutionStrategy strategy, CakeTask task, CakeReport report)
{
PerformTaskSetup(context, strategy, task, true);
strategy.Skip(task);
PerformTaskTeardown(context, strategy, task, TimeSpan.Zero, true, false);
report.AddSkipped(task.Name);
}
private async Task ExecuteTaskAsync(ICakeContext context, IExecutionStrategy strategy, CancellationTokenSource cts, CakeTask task, CakeReport report)
{
_log.Verbose($"Starting task {task.Name}");
var stopwatch = Stopwatch.StartNew();
PerformTaskSetup(context, strategy, task, false);
var execptionWasThrown = false;
try
{
var taskExecutionContext = new TaskExecutionContext(context, task);
await strategy.ExecuteAsync(task, taskExecutionContext).ConfigureAwait(false);
}
catch (TaskCanceledException)
{
execptionWasThrown = true;
throw;
}
catch (Exception exception)
{
execptionWasThrown = true;
_log.Error($"An error occurred when executing task '{task.Name}'.");
if (task.ErrorReporter != null)
{
ReportErrors(strategy, task.ErrorReporter, exception);
}
if (task.ErrorHandler != null)
{
HandleErrors(strategy, task.ErrorHandler, exception);
}
else
{
cts.Cancel();
throw;
}
}
finally
{
strategy.InvokeFinally(task.FinallyHandler);
PerformTaskTeardown(context, strategy, task, stopwatch.Elapsed, false, execptionWasThrown);
}
if (isDelegatedTask(task))
{
report.AddDelegated(task.Name, stopwatch.Elapsed);
}
else
{
report.Add(task.Name, stopwatch.Elapsed);
}
}
