public void Should_Zip_Provided_Files()
{
// Given
var environment = FakeEnvironment.CreateUnixEnvironment();
var fileSystem = new FakeFileSystem(environment);
var globber = new Globber(fileSystem, environment);
var context = new CakeContextFixture {
Environment = environment, FileSystem = fileSystem, Globber = globber
}.CreateContext();
fileSystem.CreateFile("/File1.txt").SetContent("1");
fileSystem.CreateFile("/Dir1/File2.txt").SetContent("22");
fileSystem.CreateFile("/Dir2/File3.txt").SetContent("333");
fileSystem.CreateFile("/Dir2/Dir3/File4.txt").SetContent("4444");
fileSystem.CreateFile("/Dir2/Dir3/File5.txt").SetContent("55555");
var log = Substitute.For <ICakeLog>();
var zipper = new Zipper(fileSystem, environment, log);
// When
zipper.Zip("/", "/Root.zip", context.GetFiles("/**/*.txt"));
// Then
var archive = new ZipArchive(fileSystem.GetFile("/Root.zip").Open(FileMode.Open, FileAccess.Read, FileShare.Read));
Assert.True(archive.Entries.Count == 8);
Assert.True(archive.GetEntry("Dir1/")?.Length == 0); // directory entries
Assert.True(archive.GetEntry("Dir2/")?.Length == 0);
Assert.True(archive.GetEntry("Dir2/Dir3/")?.Length == 0);
Assert.True(archive.GetEntry("File1.txt")?.Length == 1); // file entries
Assert.True(archive.GetEntry("Dir1/File2.txt")?.Length == 2);
Assert.True(archive.GetEntry("Dir2/File3.txt")?.Length == 3);
Assert.True(archive.GetEntry("Dir2/Dir3/File4.txt")?.Length == 4);
Assert.True(archive.GetEntry("Dir2/Dir3/File5.txt")?.Length == 5);
}
public TheCreateFolderMethod(CakeContextFixture fixture)
{
_Context = fixture;
_Settings = new SsrsConnectionSettings
{
ServiceEndpoint = fixture.ServiceEndpoint,
UseDefaultCredentials = true
};
}
public TheUploadDataSourceMethod(CakeContextFixture fixture)
{
_Context = fixture;
_Settings = new SsrsConnectionSettings
{
ServiceEndpoint = fixture.ServiceEndpoint,
UseDefaultCredentials = true
};
}
public FileCopierFixture()
{
_environment = FakeEnvironment.CreateUnixEnvironment();
_environment.WorkingDirectory = "/working";
_fileSystem = new FakeFileSystem(_environment);
_globber = new Globber(_fileSystem, _environment);
Context = new CakeContextFixture {
Environment = _environment, FileSystem = _fileSystem, Globber = _globber
}.CreateContext();
}
public void Should_Return_Provided_File_System()
{
// Given
var fixture = new CakeContextFixture();
var context = fixture.CreateContext();
// When
var fileSystem = context.FileSystem;
// Then
Assert.Same(fixture.FileSystem, fileSystem);
}
public void Should_Return_Provided_Log()
{
// Given
var fixture = new CakeContextFixture();
var context = fixture.CreateContext();
// When
var log = context.Log;
// Then
Assert.Same(fixture.Log, log);
}
public void Should_Return_Provided_Globber()
{
// Given
var fixture = new CakeContextFixture();
var context = fixture.CreateContext();
// When
var globber = context.Globber;
// Then
Assert.Same(fixture.Globber, globber);
}
public void Should_Return_Provided_Configuration()
{
// Given
var fixture = new CakeContextFixture();
var context = fixture.CreateContext();
// When
var configuration = context.Configuration;
// Then
Assert.Same(fixture.Configuration, configuration);
}
public void Should_Return_Provided_Environment()
{
// Given
var fixture = new CakeContextFixture();
var context = fixture.CreateContext();
// When
var environment = context.Environment;
// Then
Assert.Same(fixture.Environment, environment);
}
public void Should_Return_Provided_Arguments()
{
// Given
var fixture = new CakeContextFixture();
var context = fixture.CreateContext();
// When
var arguments = context.Arguments;
// Then
Assert.Same(fixture.Arguments, arguments);
}
public void Should_Return_Provided_Process_Runner()
{
// Given
var fixture = new CakeContextFixture();
var context = fixture.CreateContext();
// When
var processRunner = context.ProcessRunner;
// Then
Assert.Same(fixture.ProcessRunner, processRunner);
}
public void Should_Throw_If_Process_Runner_Is_Null()
{
// Given
var fixture = new CakeContextFixture();
fixture.ProcessRunner = null;
// When
var result = Record.Exception(() => fixture.CreateContext());
// Then
Assert.IsArgumentNullException(result, "processRunner");
}
public void Should_Throw_If_File_System_Is_Null()
{
// Given
var fixture = new CakeContextFixture();
fixture.FileSystem = null;
// When
var result = Record.Exception(() => fixture.CreateContext());
// Then
Assert.IsArgumentNullException(result, "fileSystem");
}
public void Should_Throw_If_Log_Is_Null()
{
// Given
var fixture = new CakeContextFixture();
fixture.Log = null;
// When
var result = Record.Exception(() => fixture.CreateContext());
// Then
AssertEx.IsArgumentNullException(result, "log");
}
public void Should_Throw_If_Environment_Is_Null()
{
// Given
var fixture = new CakeContextFixture();
fixture.Environment = null;
// When
var result = Record.Exception(() => fixture.CreateContext());
// Then
Assert.IsArgumentNullException(result, "environment");
}
public void Should_Throw_If_Resolver_Could_Not_Be_Found()
{
// Given
var fixture = new CakeContextFixture();
var context = fixture.CreateContext();
// When
var result = Record.Exception(() => context.GetToolResolver("Foo"));
// Then
Assert.IsType <CakeException>(result);
Assert.Equal("Failed to resolve tool: Foo", result.Message);
}
public void Should_Throw_If_Arguments_Are_Null()
{
// Given
var fixture = new CakeContextFixture();
fixture.Arguments = null;
// When
var result = Record.Exception(() => fixture.CreateContext());
// Then
Assert.IsArgumentNullException(result, "arguments");
}
public async Task Should_Only_Aggregate_Exceptions_When_There_Are_Many()
{
// Given
var task = new CakeTask("task");
var context = new CakeContextFixture().CreateContext();
// When
task.Actions.Add((c) => throw new NotImplementedException());
task.SetDeferExceptions(true);
var result = await Record.ExceptionAsync(() => 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
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);
}
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 async Task Should_Throw_On_First_Failed_Action()
{
// Given
var task = new CakeTask("task");
var context = new CakeContextFixture().CreateContext();
// When
task.Actions.Add((c) => throw new NotImplementedException());
task.Actions.Add((c) => throw new NotSupportedException());
task.Actions.Add((c) => throw new OutOfMemoryException());
var result = await Record.ExceptionAsync(() => task.Execute(context));
// Then
Assert.IsType <NotImplementedException>(result);
}
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_Find_Tool_By_Name_Regardless_Of_Casing(string name)
{
// Given
var fixture = new CakeContextFixture();
var resolver = Substitute.For <IToolResolver>();
resolver.Name.Returns("Foo");
fixture.ToolResolvers.Add(resolver);
var context = fixture.CreateContext();
// When
var result = context.GetToolResolver(name);
// Then
Assert.Equal(resolver, 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);
}
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_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 async Task Should_Aggregate_Exceptions_From_Actions()
{
// Given
var task = new CakeTask("task");
var context = new CakeContextFixture().CreateContext();
// When
task.Actions.Add((c) => throw new NotImplementedException());
task.Actions.Add((c) => throw new NotSupportedException());
task.Actions.Add((c) => throw new OutOfMemoryException());
task.SetDeferExceptions(true);
var result = await Record.ExceptionAsync(() => 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));
}
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));
}
public TheHttpDeleteMethod(CakeContextFixture fixture)
{
_Context = fixture;
}
