public void MoveItem_WherePathIsDirectoryAndDestinationDirectoryIsDifferent_MovesDirectory() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var subDirectory2Items = fileSystemFixture.SubDirectory2Items; var original = (DirectoryInfoContract)rootDirectoryItems.Single(i => i.Name == "SubDir"); var moved = default(DirectoryInfoContract); var gatewayMock = mockingFixture.InitializeGetChildItems(rootName, @"\SubDir2", rootDirectoryItems, subDirectory2Items); gatewayMock.Setup(g => g.MoveItem(rootName, new DirectoryId(@"\SubDir"), @"SubDirMove", new DirectoryId(@"\SubDir2"))) .Returns(moved = new DirectoryInfoContract(original.Id.Value.Replace("SubDir", "SubDirMove"), original.Name.Replace("SubDir", "SubDirMove"), original.Created, original.Updated)) .Verifiable(); compositionFixture.ExportGateway(gatewayMock.Object); var result = new PipelineFixture().Invoke( FileSystemFixture.NewDriveCommand, @"Move-Item -Path X:\SubDir -Destination X:\SubDir2\SubDirMove", @"Get-ChildItem -Path X:\SubDir2" ); Assert.AreEqual(subDirectory2Items.Count() + 1, result.Count, "Unexpected number of results"); CollectionAssert.Contains(result.Select(p => p.BaseObject).ToArray(), moved, "Moved item is missing"); gatewayMock.VerifyAll(); }
public void SetContent_WhereNodeIsFileAndEncryptionKeyIsSpecified_EncryptsContent() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var content = TestContent.MultiLineTestContent.Select(c => Convert.ToByte(c)).ToArray(); var gatewayMock = mockingFixture.InitializeGetChildItems(rootName, @"\", rootDirectoryItems); gatewayMock.Setup(g => g.ClearContent(rootName, new FileId(@"\File.ext"))).Verifiable(); Func <Stream, byte[], bool> matches = (s, c) => { var d = s.Decrypt(FileSystemFixture.EncryptionKey); return(new BinaryReader(d, System.Text.Encoding.Default, true).ReadBytes((int)d.Length).SequenceEqual(content)); }; gatewayMock.Setup(g => g.SetContent(rootName, new FileId(@"\File.ext"), It.Is <Stream>(s => matches(s, content)), It.Is <IProgress <ProgressValue> >(p => true))).Verifiable(); compositionFixture.ExportGateway(gatewayMock.Object); var pipelineFixture = new PipelineFixture(); pipelineFixture.SetVariable("value", content); pipelineFixture.Invoke( FileSystemFixture.NewDriveCommandWithEncryptionKey, @"Set-Content -Path X:\File.ext $value -Encoding Byte" ); gatewayMock.VerifyAll(); }
public void MoveItemAsync_WherePathIsFileAndDestinationDirectoryIsDifferent_MovesFile() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var subDirectoryItems = fileSystemFixture.SubDirectoryItems; var original = (FileInfoContract)subDirectoryItems.Single(i => i.Name == "SubFile.ext"); var moved = default(FileInfoContract); var gatewayMock = mockingFixture.InitializeGetChildItemsAsync(rootName, @"\SubDir", rootDirectoryItems, subDirectoryItems); gatewayMock.Setup(g => g.MoveItemAsync(rootName, new FileId(@"\File.ext"), @"FileMove.ext", new DirectoryId(@"\SubDir"), It.IsAny <Func <FileSystemInfoLocator> >())) .ReturnsAsync(moved = new FileInfoContract(original.Id.Value.Replace("File", "FileMove"), original.Name.Replace("File", "FileMove"), original.Created, original.Updated, original.Size, original.Hash)) .Verifiable(); compositionFixture.ExportAsyncGateway(gatewayMock.Object); var result = new PipelineFixture().Invoke( FileSystemFixture.NewDriveCommand, @"Move-Item -Path X:\File.ext -Destination X:\SubDir\FileMove.ext", @"Get-ChildItem -Path X:\SubDir" ); Assert.AreEqual(subDirectoryItems.Count() + 1, result.Count, "Unexpected number of results"); CollectionAssert.Contains(result.Select(p => p.BaseObject).ToArray(), moved, "Copied item is missing"); gatewayMock.VerifyAll(); }
public void SetContentAsync_WhereNodeIsFileAndPassThruIsSet_ReturnsContent() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var content = TestContent.MultiLineTestContent.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); var gatewayMock = mockingFixture.InitializeGetChildItemsAsync(rootName, @"\", rootDirectoryItems); gatewayMock.Setup(g => g.ClearContentAsync(rootName, new FileId(@"\File.ext"), It.IsAny <Func <FileSystemInfoLocator> >())) .ReturnsAsync(true) .Verifiable(); gatewayMock.Setup(g => g.SetContentAsync(rootName, new FileId(@"\File.ext"), It.Is <Stream>(s => new StreamReader(s, System.Text.Encoding.Default, true, 1024, true).ReadToEnd().TrimEnd('\r', '\n') == string.Join("\r\n", content)), It.Is <IProgress <ProgressValue> >(p => true), It.IsAny <Func <FileSystemInfoLocator> >())) .ReturnsAsync(true) .Verifiable(); compositionFixture.ExportAsyncGateway(gatewayMock.Object); var pipelineFixture = new PipelineFixture(); pipelineFixture.SetVariable("value", content); var result = pipelineFixture.Invoke( FileSystemFixture.NewDriveCommand, @"Set-Content -Path X:\File.ext $value -PassThru" ); Assert.AreEqual(1, result.Count, "Unexpected number of results"); Assert.IsInstanceOfType(result[0].BaseObject, typeof(string[]), "Results is not of type string[]"); CollectionAssert.AreEqual(content, (string[])result[0].BaseObject, "Mismatching content"); gatewayMock.VerifyAll(); }
public void RenameItemAsync_WherePathIsFile_RenamesFile() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var original = (FileInfoContract)rootDirectoryItems.Single(i => i.Name == "File.ext"); var renamed = default(FileInfoContract); var gatewayMock = mockingFixture.InitializeGetChildItemsAsync(rootName, @"\", rootDirectoryItems); gatewayMock.Setup(g => g.RenameItemAsync(rootName, new FileId(@"\File.ext"), "FileRenamed.ext", It.IsAny <Func <FileSystemInfoLocator> >())) .ReturnsAsync(renamed = new FileInfoContract(original.Id.Value.Replace("File", "FileRenamed"), original.Name.Replace("File", "FileRenamed"), original.Created, original.Updated, original.Size, original.Hash)) .Verifiable(); compositionFixture.ExportAsyncGateway(gatewayMock.Object); var result = new PipelineFixture().Invoke( FileSystemFixture.NewDriveCommand, @"Rename-Item -Path X:\File.ext -NewName FileRenamed.ext", @"Get-ChildItem -Path X:\" ); Assert.AreEqual(rootDirectoryItems.Count(), result.Count, "Unexpected number of results"); CollectionAssert.DoesNotContain(result.Select(p => p.BaseObject).ToArray(), original, "Unrenamed original remains"); CollectionAssert.Contains(result.Select(p => p.BaseObject).ToArray(), renamed, "Renamed item is missing"); gatewayMock.VerifyAll(); }
public void NewItemAsync_WherePathIsIncompleteAndItemTypeIsFile_CreatesNewFile() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var newIntermediateDirectory = new DirectoryInfoContract(@"\NewSubDir", "NewSubDir", DateTime.Now, DateTime.Now); var newItem = new FileInfoContract(@"\NewSubDir\NewSubFile", "NewSubFile", DateTime.Now, DateTime.Now, 0, null); var gatewayMock = mockingFixture.InitializeGetChildItemsAsync(rootName, @"\", rootDirectoryItems); gatewayMock.Setup(g => g.NewDirectoryItemAsync(rootName, new DirectoryId(@"\"), "NewSubDir")) .ReturnsAsync(newIntermediateDirectory) .Verifiable(); gatewayMock.Setup(g => g.NewFileItemAsync(rootName, new DirectoryId(@"\NewSubDir"), "NewSubFile", null, It.Is <IProgress <ProgressValue> >(p => true))) .ReturnsAsync(newItem) .Verifiable(); var subDirs = new Queue <string>(new[] { @"\", @"\NewSubDir" }); var predicateIterator = new Func <string, bool>(s => s == subDirs.Dequeue()); gatewayMock.SetupSequence(g => g.GetChildItemAsync(rootName, It.Is <DirectoryId>(d => predicateIterator(d.Value)))) .ReturnsAsync(new FileSystemInfoContract[0]) .ReturnsAsync(new FileSystemInfoContract[0]) .ThrowsAsync(new InvalidOperationException(@"Redundant access to directory")); compositionFixture.ExportAsyncGateway(gatewayMock.Object); var result = new PipelineFixture().Invoke( FileSystemFixture.NewDriveCommand, @"New-Item -Type File -Path X:\NewSubDir -Name NewSubFile -Force", @"Get-ChildItem -Path X:\ -Filter 'NewSub*' -Recurse" ); Assert.AreEqual(2, result.Count, "Unexpected number of results"); CollectionAssert.AreEqual(result.Select(i => i.BaseObject).ToArray(), new FileSystemInfoContract[] { newIntermediateDirectory, newItem }, "Unexpected result"); gatewayMock.VerifyAll(); }
public void CopyItem_WherePathIsFile_CopiesFile() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var original = (FileInfoContract)rootDirectoryItems.Single(i => i.Name == "File.ext"); var copy = default(FileInfoContract); var gatewayMock = mockingFixture.InitializeGetChildItems(rootName, @"\", rootDirectoryItems); gatewayMock.Setup(g => g.CopyItem(rootName, new FileId(@"\File.ext"), @"FileCopy.ext", new DirectoryId(@"\"), false)) .Returns(copy = new FileInfoContract(original.Id.Value.Replace("File", "FileCopy"), original.Name.Replace("File", "FileCopy"), original.Created, original.Updated, original.Size, original.Hash)) .Verifiable(); compositionFixture.ExportGateway(gatewayMock.Object); var result = new PipelineFixture().Invoke( FileSystemFixture.NewDriveCommand, @"Copy-Item -Path X:\File.ext -Destination X:\FileCopy.ext", @"Get-ChildItem -Path X:\" ); Assert.AreEqual(rootDirectoryItems.Count() + 1, result.Count, "Unexpected number of results"); CollectionAssert.Contains(result.Select(p => p.BaseObject).ToArray(), original, "Original item is missing"); CollectionAssert.Contains(result.Select(p => p.BaseObject).ToArray(), copy, "Copied item is missing"); gatewayMock.VerifyAll(); }
public void NewItemAsync_WhereItemIsAlreadyPresent_Throws() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var content = TestContent.SingleLineTestContent; var gatewayMock = mockingFixture.InitializeGetChildItemsAsync(rootName, @"\", rootDirectoryItems); compositionFixture.ExportAsyncGateway(gatewayMock.Object); try { var pipelineFixture = new PipelineFixture(); pipelineFixture.SetVariable("value", content); pipelineFixture.Invoke( FileSystemFixture.NewDriveCommand, @"New-Item -Type File -Path X:\ -Name File.ext -Value $value" ); throw new InvalidOperationException("Expected Exception was not thrown"); } catch (AssertFailedException ex) { Assert.IsTrue(ex.Message.EndsWith("NotSpecified: (X:\\File.ext:String) [New-Item], NotSupportedException", StringComparison.Ordinal)); } gatewayMock.VerifyAll(); }
public void NewItemAsync_WhereEncryptionKeyIsSpecifiedAndItemTypeIsFile_PassesEncryptedValue() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var content = TestContent.SingleLineTestContent; var newItem = new FileInfoContract(@"\NewFile", "NewFile", DateTime.Now, DateTime.Now, content.Length, FileSystemFixture.GetHash(content)); var gatewayMock = mockingFixture.InitializeGetChildItemsAsync(rootName, @"\", rootDirectoryItems); gatewayMock.Setup(g => g.NewFileItemAsync(rootName, new DirectoryId(@"\"), "NewFile", It.Is <Stream>(s => EncryptionFixture.GetDecryptingReader(s, FileSystemFixture.EncryptionKey).ReadToEnd() == content), It.Is <IProgress <ProgressValue> >(p => true))) .ReturnsAsync(newItem) .Verifiable(); compositionFixture.ExportAsyncGateway(gatewayMock.Object); var pipelineFixture = new PipelineFixture(); pipelineFixture.SetVariable("value", content); var result = pipelineFixture.Invoke( FileSystemFixture.NewDriveCommandWithEncryptionKey, @"New-Item -Type File -Path X:\ -Name NewFile -Value $value" ); Assert.AreEqual(1, result.Count, "Unexpected number of results"); Assert.AreEqual(newItem, result[0].BaseObject, "Mismatching result"); gatewayMock.VerifyAll(); }
public void NewItemAsync_WherePathIsSubDirAndItemTypeIsFile_CanRemoveNewFile() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var subDirectoryItems = fileSystemFixture.SubDirectoryItems; var newItem = new FileInfoContract(@"\SubDir\NewSubFile", "NewSubFile", DateTime.Now, DateTime.Now, 0, null); var gatewayMock = mockingFixture.InitializeGetChildItemsAsync(rootName, @"\SubDir", rootDirectoryItems, subDirectoryItems); gatewayMock.Setup(g => g.NewFileItemAsync(rootName, new DirectoryId(@"\SubDir"), "NewSubFile", null, It.Is <IProgress <ProgressValue> >(p => true))) .ReturnsAsync(newItem) .Verifiable(); gatewayMock.Setup(g => g.RemoveItemAsync(rootName, new FileId(@"\SubDir\NewSubFile"), false)) .ReturnsAsync(true) .Verifiable(); compositionFixture.ExportAsyncGateway(gatewayMock.Object); var result = new PipelineFixture().Invoke( FileSystemFixture.NewDriveCommand, @"New-Item -Type File -Path X:\SubDir -Name NewSubFile", @"Remove-Item -Path X:\SubDir\NewSubFile", @"Get-ChildItem -Path X:\SubDir" ); Assert.AreEqual(subDirectoryItems.Length, result.Count, "Unexpected number of results"); CollectionAssert.DoesNotContain(result.Select(p => p.BaseObject).ToArray(), newItem, "Excessive result"); gatewayMock.VerifyAll(); }
public void NewItemAsync_WherePathIsSubDirAndItemTypeIsDirectory_CreatesNewDirectory() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var subDirectoryItems = fileSystemFixture.SubDirectoryItems; var newItem = new DirectoryInfoContract(@"\SubDir\NewSubSubDir", "NewSubSubDir", DateTime.Now, DateTime.Now); var gatewayMock = mockingFixture.InitializeGetChildItemsAsync(rootName, @"\SubDir", rootDirectoryItems, subDirectoryItems); gatewayMock.Setup(g => g.NewDirectoryItemAsync(rootName, new DirectoryId(@"\SubDir"), "NewSubSubDir")) .ReturnsAsync(newItem) .Verifiable(); compositionFixture.ExportAsyncGateway(gatewayMock.Object); var result = new PipelineFixture().Invoke( FileSystemFixture.NewDriveCommand, @"New-Item -Type Directory -Path X:\SubDir -Name NewSubSubDir", @"Get-ChildItem -Path X:\SubDir" ); Assert.AreEqual(subDirectoryItems.Length + 1, result.Count, "Unexpected number of results"); CollectionAssert.Contains(result.Select(p => p.BaseObject).ToArray(), newItem, "Missing result"); gatewayMock.VerifyAll(); }
public void GetChildItemAsync_WherePathIsSubDirectoryAndForceIsSpecified_RefreshesResult() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var subDirectoryItems = fileSystemFixture.SubDirectoryItems; var subDirectoryItemsRefreshed = fileSystemFixture.SubDirectoryItems .Select(f => f is FileInfoContract ? new FileInfoContract(f.Id.Value.Insert(f.Id.Value.IndexOf(".ext", StringComparison.Ordinal), "Refreshed"), f.Name.Insert(f.Name.IndexOf(".ext", StringComparison.Ordinal), "Refreshed"), f.Created, f.Updated, ((FileInfoContract)f).Size, ((FileInfoContract)f).Hash) as FileSystemInfoContract : new DirectoryInfoContract(f.Id + "Refreshed", f.Name + "Refreshed", f.Created, f.Updated) as FileSystemInfoContract) .ToArray(); var gatewayMock = new MockingFixture().InitializeGetChildItemsAsync(rootName, string.Empty, rootDirectoryItems); gatewayMock.SetupSequence(g => g.GetChildItemAsync(rootName, new DirectoryId(@"\SubDir"))) .ReturnsAsync(subDirectoryItems) .ReturnsAsync(subDirectoryItemsRefreshed) .ThrowsAsync(new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, @"Redundant access to \SubDir"))); compositionFixture.ExportAsyncGateway(gatewayMock.Object); var result = new PipelineFixture().Invoke( FileSystemFixture.NewDriveCommand, @"Get-ChildItem -Path X:\SubDir", @"Get-ChildItem -Path X:\SubDir -Force" ); Assert.AreEqual(subDirectoryItemsRefreshed.Length, result.Count, "Unexpected number of results"); CollectionAssert.AreEquivalent(subDirectoryItemsRefreshed, result.Select(p => p.BaseObject).Cast <FileSystemInfoContract>().ToList()); }
public void RenameItem_WherePathIsDirectoryInSubDirectory_RenamesDirectory() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var subDirectoryItems = fileSystemFixture.SubDirectoryItems; var original = (DirectoryInfoContract)subDirectoryItems.Single(i => i.Name == "SubSubDir"); var renamed = default(DirectoryInfoContract); var gatewayMock = mockingFixture.InitializeGetChildItems(rootName, @"\SubDir", rootDirectoryItems, subDirectoryItems); gatewayMock.Setup(g => g.RenameItem(rootName, new DirectoryId(@"\SubDir\SubSubDir"), "SubSubDirRenamed")) .Returns(renamed = new DirectoryInfoContract(original.Id.Value.Replace("SubSubDir", "SubSubDirRenamed"), original.Name.Replace("SubSubDir", "SubSubDirRenamed"), original.Created, original.Updated)) .Verifiable(); compositionFixture.ExportGateway(gatewayMock.Object); var result = new PipelineFixture().Invoke( FileSystemFixture.NewDriveCommand, @"Rename-Item -Path X:\SubDir\SubSubDir -NewName SubSubDirRenamed", @"Get-ChildItem -Path X:\SubDir" ); Assert.AreEqual(subDirectoryItems.Count(), result.Count, "Unexpected number of results"); CollectionAssert.DoesNotContain(result.Select(p => p.BaseObject).ToArray(), original, "Unrenamed original remains"); CollectionAssert.Contains(result.Select(p => p.BaseObject).ToArray(), renamed, "Renamed item is missing"); gatewayMock.VerifyAll(); }
public void SetContentAsync_WhereNodeIsFileAndEncodingIsByte_AcceptsContent() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var content = TestContent.MultiLineTestContent.Select(c => Convert.ToByte(c)).ToArray(); var gatewayMock = mockingFixture.InitializeGetChildItemsAsync(rootName, @"\", rootDirectoryItems); gatewayMock.Setup(g => g.ClearContentAsync(rootName, new FileId(@"\File.ext"), It.IsAny <Func <FileSystemInfoLocator> >())) .ReturnsAsync(true) .Verifiable(); gatewayMock.Setup(g => g.SetContentAsync(rootName, new FileId(@"\File.ext"), It.Is <Stream>(s => new BinaryReader(s, System.Text.Encoding.Default, true).ReadBytes((int)s.Length).SequenceEqual(content)), It.Is <IProgress <ProgressValue> >(p => true), It.IsAny <Func <FileSystemInfoLocator> >())) .ReturnsAsync(true) .Verifiable(); compositionFixture.ExportAsyncGateway(gatewayMock.Object); var pipelineFixture = new PipelineFixture(); pipelineFixture.SetVariable("value", content); pipelineFixture.Invoke( FileSystemFixture.NewDriveCommand, @"Set-Content -Path X:\File.ext $value -Encoding Byte" ); gatewayMock.VerifyAll(); }
public void CopyItemAsync_WherePathIsDirectoryInSubDirectory_CopiesDirectory() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var subDirectoryItems = fileSystemFixture.SubDirectoryItems; var original = (DirectoryInfoContract)subDirectoryItems.Single(i => i.Name == "SubSubDir"); var copied = default(DirectoryInfoContract); var gatewayMock = mockingFixture.InitializeGetChildItemsAsync(rootName, @"\SubDir", rootDirectoryItems, subDirectoryItems); gatewayMock.Setup(g => g.CopyItemAsync(rootName, new DirectoryId(@"\SubDir\SubSubDir"), "SubSubDirCopy", new DirectoryId(@"\SubDir"), false)) .ReturnsAsync(copied = new DirectoryInfoContract(original.Id.Value.Replace("SubSubDir", "SubSubDirCopy"), original.Name.Replace("SubSubDir", "SubSubDirCopy"), original.Created, original.Updated)) .Verifiable(); compositionFixture.ExportAsyncGateway(gatewayMock.Object); var result = new PipelineFixture().Invoke( FileSystemFixture.NewDriveCommand, @"Copy-Item -Path X:\SubDir\SubSubDir -Destination X:\SubDir\SubSubDirCopy", @"Get-ChildItem -Path X:\SubDir" ); Assert.AreEqual(subDirectoryItems.Count() + 1, result.Count, "Unexpected number of results"); CollectionAssert.Contains(result.Select(p => p.BaseObject).ToArray(), original, "Original item is missing"); CollectionAssert.Contains(result.Select(p => p.BaseObject).ToArray(), copied, "Copied item is missing"); gatewayMock.VerifyAll(); }
public void SetContentAsync_WhereNodeIsFileAndEncodingIsUnknown_AcceptsContent() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var content = TestContent.MultiLineTestContent.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); var gatewayMock = mockingFixture.InitializeGetChildItemsAsync(rootName, @"\", rootDirectoryItems); gatewayMock.Setup(g => g.ClearContentAsync(rootName, new FileId(@"\File.ext"), It.IsAny <Func <FileSystemInfoLocator> >())) .ReturnsAsync(true) .Verifiable(); gatewayMock.Setup(g => g.SetContentAsync(rootName, new FileId(@"\File.ext"), It.Is <Stream>(s => new StreamReader(s, System.Text.Encoding.Default, true, 1024, true).ReadToEnd().TrimEnd('\r', '\n') == string.Join("\r\n", content)), It.Is <IProgress <ProgressValue> >(p => true), It.IsAny <Func <FileSystemInfoLocator> >())) .ReturnsAsync(true) .Verifiable(); compositionFixture.ExportAsyncGateway(gatewayMock.Object); var pipelineFixture = new PipelineFixture(); pipelineFixture.SetVariable("value", content); pipelineFixture.Invoke( FileSystemFixture.NewDriveCommand, @"Set-Content -Path X:\File.ext $value" ); gatewayMock.VerifyAll(); }
public void SetContentAsync_WherePathIsUnknownFile_Throws() { var rootName = FileSystemFixture.GetRootName(); var rootDirectoryItems = fileSystemFixture.RootDirectoryItems; var content = TestContent.MultiLineTestContent.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); var gatewayMock = mockingFixture.InitializeGetChildItemsAsync(rootName, @"\", rootDirectoryItems); compositionFixture.ExportAsyncGateway(gatewayMock.Object); try { var pipelineFixture = new PipelineFixture(); pipelineFixture.SetVariable("value", content); pipelineFixture.Invoke( FileSystemFixture.NewDriveCommand, @"Set-Content -Path X:\FileUnknown $value" ); throw new InvalidOperationException("Expected Exception was not thrown"); } catch (AssertFailedException ex) { Assert.IsTrue(ex.Message.EndsWith(@"ObjectNotFound: (X:\FileUnknown:String) [Set-Content], ItemNotFoundException", StringComparison.Ordinal)); } gatewayMock.VerifyAll(); }
public void Should_Delete_Directory_With_Content_If_Recursive() { // Given var fixture = new FileSystemFixture(); var context = Substitute.For<ICakeContext>(); context.FileSystem.Returns(fixture.FileSystem); // When context.DeleteDirectory("/Temp/Hello", true); // Then Assert.False(fixture.FileSystem.GetDirectory("/Temp/Hello").Exists); }
public void Should_Throw_If_Directory_Is_Null() { // Given var fixture = new FileSystemFixture(); var context = Substitute.For<ICakeContext>(); context.FileSystem.Returns(fixture.FileSystem); // When var result = Record.Exception(() => context.DeleteDirectory(null)); // Then Assert.IsArgumentNullException(result, "path"); }
public void Should_Delete_Files_In_Provided_Directory() { // Given var directory = new DirectoryPath("/Temp/Hello"); var fixture = new FileSystemFixture(); var context = Substitute.For<ICakeContext>(); context.FileSystem.Returns(fixture.FileSystem); // When DirectoryAliases.CleanDirectory(context, directory); // Then Assert.Empty(fixture.FileSystem.GetDirectory(directory).GetFiles("*", SearchScope.Recursive)); }
public void Should_Create_Directory_If_Missing() { // Given var directory = new DirectoryPath("/NonExisting"); var fixture = new FileSystemFixture(); var context = Substitute.For<ICakeContext>(); context.FileSystem.Returns(fixture.FileSystem); // When DirectoryAliases.CleanDirectory(context, directory); // Then Assert.True(fixture.FileSystem.Exist((DirectoryPath)"/NonExisting")); }
public void Should_Leave_Provided_Directory_Itself_Intact() { // Given var directory = new DirectoryPath("/Temp/Hello"); var fixture = new FileSystemFixture(); var context = Substitute.For<ICakeContext>(); context.FileSystem.Returns(fixture.FileSystem); // When DirectoryAliases.CleanDirectory(context, directory); // Then Assert.True(fixture.FileSystem.GetDirectory(directory).Exists); }
public void Should_Delete_Empty_Directory_If_Non_Recursive() { // Given var fixture = new FileSystemFixture(); var context = Substitute.For <ICakeContext>(); context.FileSystem.Returns(fixture.FileSystem); // When DirectoryExtensions.DeleteDirectory(context, "/Temp/Hello/Empty"); // Then Assert.False(fixture.FileSystem.GetDirectory("/Temp/Hello/Empty").Exists); }
public File_ReadWrite_RoundTrip_Tests(ITestOutputHelper output, FileSystemFixture fileSystemFixture) { if (output == null) { throw new ArgumentNullException(nameof(output)); } if (fileSystemFixture == null) { throw new ArgumentNullException(nameof(fileSystemFixture)); } _output = output; _fileSystemFixture = fileSystemFixture; }
public void Should_Throw_When_Deleting_Directory_With_Files_If_Non_Recursive() { // Given var fixture = new FileSystemFixture(); var context = Substitute.For<ICakeContext>(); context.FileSystem.Returns(fixture.FileSystem); // When var result = Record.Exception(() => context.DeleteDirectory("/Temp/HasFiles")); // Then Assert.IsType<IOException>(result); Assert.Equal("Cannot delete directory '/Temp/HasFiles' without recursion since it's not empty.", result.Message); }
public void Should_Throw_If_Directory_Do_Not_Exist() { // Given var fixture = new FileSystemFixture(); var context = Substitute.For<ICakeContext>(); context.FileSystem.Returns(fixture.FileSystem); // When var result = Record.Exception(() => context.DeleteDirectory("/Temp/DoNotExist")); // Then Assert.IsType<IOException>(result); Assert.Equal("The directory '/Temp/DoNotExist' do not exist.", result.Message); }
public void Should_Delete_Directories_Respecting_Predicate_In_Provided_Directory() { // Given var fixture = new FileSystemFixture(); var context = Substitute.For<ICakeContext>(); context.FileSystem.Returns(fixture.FileSystem); var directory = fixture.FileSystem.GetDirectory("/Temp/Hello"); // When DirectoryAliases.CleanDirectory(context, directory.Path, info => !info.Hidden); // Then Assert.Equal(1, directory.GetDirectories("*", SearchScope.Recursive).Count()); Assert.True(fixture.FileSystem.GetDirectory("/Temp/Hello/Hidden").Exists); }
public File_SetAttributes_Tests(ITestOutputHelper output, FileSystemFixture fileSystemFixture) { if (output == null) { throw new ArgumentNullException(nameof(output)); } if (fileSystemFixture == null) { throw new ArgumentNullException(nameof(fileSystemFixture)); } _output = output; _fileSystemFixture = fileSystemFixture; }
public DirectoryInfo_FullName_Tests(ITestOutputHelper output, FileSystemFixture fileSystemFixture) { if (output == null) { throw new ArgumentNullException(nameof(output)); } if (fileSystemFixture == null) { throw new ArgumentNullException(nameof(fileSystemFixture)); } _output = output; _fileSystemFixture = fileSystemFixture; }
public void Should_Delete_Empty_Directory_If_Non_Recursive() { // Given var fixture = new FileSystemFixture(); var context = Substitute.For<ICakeContext>(); context.FileSystem.Returns(fixture.FileSystem); var paths = new[] { "/Temp/Hello/Empty", "/Temp/Hello/More/Empty" }; // When context.DeleteDirectories(paths); // Then Assert.False(fixture.FileSystem.GetDirectory("/Temp/Hello/Empty").Exists); Assert.False(fixture.FileSystem.GetDirectory("/Temp/Hello/More/Empty").Exists); }