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