public void WhenFileDoesNotExist_RelativeToCtorPath_ShouldReturnFalse() { // Arrange using var tempFolder = new AutoTempFolder(); var test = Path.Combine(tempFolder.Path, Guid.NewGuid() .ToString()); var sut = Create(tempFolder); // Act var result = sut.IsFile(test); // Assert Expect(result) .To.Be.False(); }
public void FirstLevelResultsShouldHaveCorrectRelativePath() { // Arrange using var tempFolder = new AutoTempFolder(); var path = tempFolder.CreateRandomFile(); var expected = Path.GetFileName(path); var sut = Create(tempFolder); // Act var results = sut.ListResourcesRecursive(); // Assert Expect(results) .To.Contain.Exactly(1) .Matched.By(r => r.RelativePath == expected); }
public void ShouldProvideLocalFileSystemForFileProtocol() { // Arrange using var folder = new AutoTempFolder(); var uri = new Uri(folder.Path); var sut = Create(); // Act var result = sut.FileSystemFor(uri.AbsoluteUri); // Assert Expect(result) .To.Be.An.Instance.Of <LocalFileSystem>(); Expect(result.BasePath) .To.Equal(folder.Path); }
public void Ctor_WhenBasePathDoesNotExist_ShouldAttemptToCreateIt() { // Arrange using var folder = new AutoTempFolder(); var baseFolder = Path.Combine(folder.Path, Guid.NewGuid() .ToString()); Expect(baseFolder) .Not.To.Exist(); // Act Expect(() => Create(baseFolder)) .To.Throw <DirectoryNotFoundException>(); // Assert }
public void ShouldExposeFileBinaryDataForRead() { // Arrange var data = GetRandomBytes(64); // Pre-assert // Act using (var folder = new AutoTempFolder()) using (var file = new AutoTempFile(folder.Path, data)) { var result = file.BinaryData; // Assert Expect(result).To.Equal(data); } }
public void ShouldDeleteIt() { // Arrange using var folder = new AutoTempFolder(); var relPath = GetRandomFileName(); var fullPath = Path.Combine(folder.Path, relPath); File.WriteAllBytes(fullPath, GetRandomBytes()); var sut = Create(folder.Path); // Act sut.Delete(relPath); // Assert Expect(fullPath) .Not.To.Exist(); }
public void ShouldNotThrow() { // Arrange using var folder = new AutoTempFolder(); var relPath = GetRandomFileName(); var fullPath = Path.Combine(folder.Path, relPath); Expect(fullPath) .Not.To.Exist(); var sut = Create(folder.Path); // Act Expect(() => sut.Delete(relPath)) .Not.To.Throw(); // Assert }
public void ShouldSupplyMinusOneForSizeIfUnableToStat() { // Arrange using var tempFolder = new AutoTempFolder(); var file = tempFolder.CreateRandomFile(); var stat = new FileInfo(file); var sut = Create(tempFolder); // Act var results = sut.ListResourcesRecursive(); File.Delete(file); // Assert Expect(results.Single() .Size) .To.Equal(-1); }
public void ShouldIgnoreEmptyFoldersUnderBase() { // Arrange using var tempFolder = new AutoTempFolder(); var path = tempFolder.CreateRandomFolder(); var sut = Create(tempFolder); Expect(path) .To.Exist(); // Act var results = sut.ListResourcesRecursive(); // Assert Expect(results) .To.Be.Empty(); }
public void ShouldCreateAnyRequiredContainingFolders() { // Arrange using var tempFolder = new AutoTempFolder(); var target = Path.Combine(tempFolder.Path, "level1", "level2", "output.bin"); var data = GetRandomBytes(); using var src = new MemoryStream(data); // Act src.Save(target); // Assert var persisted = File.ReadAllBytes(target); Expect(persisted) .To.Equal(data); }
public void ShouldBeAbleToReadFromStdErr() { // Arrange using var tempFolder = new AutoTempFolder(); var fileName = Path.Combine(tempFolder.Path, "test.bat"); File.WriteAllText(fileName, "echo moo 1>&2"); // Act using var io = new ProcessIO(fileName); Expect(io.StartException) .To.Be.Null(); var lines = io.StandardError.ToArray().Select(l => l.Trim()); // Assert Expect(lines).To.Equal(new[] { "moo" }); }
public void SetCurrentDirectory_ShouldStoreCurrentDirectoryAndReturnViaGetCurrentDirectory() { //---------------Set up test pack------------------- using (var folder = new AutoTempFolder()) { var sut = Create(); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- sut.SetCurrentDirectory(folder.Path); var result = sut.GetCurrentDirectory(); //---------------Test Result ----------------------- Assert.AreEqual(folder.Path, result); } }
public void Delete_GivenUnknownPath_ShouldDoNothing() { //---------------Set up test pack------------------- using (var folder = new AutoTempFolder()) { //---------------Assert Precondition---------------- var fileName = GetRandomString(); var sut = Create(); sut.SetCurrentDirectory(folder.Path); //---------------Execute Test ---------------------- Assert.DoesNotThrow(() => sut.Delete(fileName)); //---------------Test Result ----------------------- } }
public void ShouldBeAbleToRunInDifferentDirectory() { // Arrange using var tempFolder = new AutoTempFolder(); var tempFilePath = Path.Combine(tempFolder.Path, "data.txt"); var expected = GetRandomString(32); File.WriteAllText(tempFilePath, expected); // Act using var io = ProcessIO.In(tempFolder.Path).Start("cat", "data.txt"); // Assert var lines = io.StandardOutput.ToArray().Select(l => l.Trim()); Expect(lines) .To.Equal(new[] { expected }); }
public void Construct_GivenCustomBasePathWhichDoesNotExistYet_ShouldUseThatPathAsBaseForTempFolder() { //---------------Set up test pack------------------- var baseFolder = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath); baseFolder = Path.Combine(baseFolder, RandomValueGen.GetRandomString(10, 15)); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- using (var folder = new AutoTempFolder(baseFolder)) { //---------------Test Result ----------------------- Assert.AreEqual(baseFolder, Path.GetDirectoryName(folder.Path)); } }
public void Construct_ShouldMakeNewEmptyFolderAvailable() { //---------------Set up test pack------------------- //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- using (var folder = new AutoTempFolder()) { var result = folder.Path; //---------------Test Result ----------------------- Assert.IsNotNull(result); Assert.IsTrue(Directory.Exists(result)); var entries = Directory.EnumerateFileSystemEntries(result, "*", SearchOption.AllDirectories); CollectionAssert.IsEmpty(entries); } }
public void Construct_GivenNonExistentBaseFolder_ShouldCreateIt() { // Arrange using (var folder = new AutoTempFolder()) { // Pre-assert // Act var basePath = Path.Combine(folder.Path, "moo", "cow", "duck"); var data = GetRandomBytes(64); using (var file = new AutoTempFile(basePath, "stuff.blob", data)) { var onDisk = File.ReadAllBytes(file.Path); // Assert Expect(onDisk).To.Equal(data); } } }
public void ShouldAllowSettingStringData() { // Arrange var original = GetRandomString(128); var expected = GetAnother(original, () => GetRandomString(128)); // Pre-assert // Act using (var folder = new AutoTempFolder()) using (var file = new AutoTempFile(folder.Path, original)) { file.StringData = expected; var result = Encoding.UTF8.GetString(File.ReadAllBytes(file.Path)); // Assert Expect(result).To.Equal(expected); } }
public void ShouldExposeFileBinaryDataForWrite() { // Arrange var original = GetRandomBytes(64); var expected = GetAnother(original, () => GetRandomBytes(64)); // Pre-assert // Act using (var folder = new AutoTempFolder()) using (var file = new AutoTempFile(folder.Path, original)) { file.BinaryData = expected; var result = File.ReadAllBytes(file.Path); // Assert Expect(result).To.Equal(expected); } }
public void ShouldSupplySizeOnDemand() { // Arrange using var tempFolder = new AutoTempFolder(); var file = tempFolder.CreateRandomFile(); var stat = new FileInfo(file); var newData = GetRandomBytes((int)stat.Length + 1, (int)stat.Length + 100); var sut = Create(tempFolder); // Act var results = sut.ListResourcesRecursive(); File.WriteAllBytes(file, newData); // Assert Expect(results.Single() .Size) .To.Equal(newData.Length); }
public void ListRecursive_ShouldReturnAllFilesAndDirectoriesUnderThatPath() { //---------------Set up test pack------------------- using (var folder = new AutoTempFolder()) { var expected = CreateRandomFileTreeIn(folder.Path); var sut = Create(); sut.SetCurrentDirectory(folder.Path); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- var result = sut.ListRecursive(); //---------------Test Result ----------------------- CollectionAssert.AreEquivalent(expected, result); } }
public void ShouldIgnoreDotFilesByDefault() { // Arrange using var folder = new AutoTempFolder(); var fileName = ".{GetRandomString(1)}"; File.WriteAllBytes( Path.Combine(folder.Path, fileName), GetRandomBytes() ); var sut = Create(folder); // Act var result = sut.ListResourcesRecursive(); // Assert Expect(result) .To.Be.Empty(); }
public void ShouldNotThrow() { // Arrange using (var tempFolder = new AutoTempFolder()) { var folderPath = Path.Combine( tempFolder.Path, GetRandomString(5) ); Directory.CreateDirectory(folderPath); // Act Assert.That(() => { Expect(folderPath).To.Exist(); }, Throws.Nothing); // Assert } }
public void WhenDirectoryDoesNotExist_RelativeToCtorPath_ShouldReturnFalse() { // Arrange using var tempDir = new AutoTempFolder(); var test = Guid.NewGuid() .ToString(); var sub = Path.Combine(tempDir.Path, test); Expect(sub) .Not.To.Exist(); var sut = Create(tempDir.Path); // Act var result = sut.IsDirectory(test); // Assert Expect(result) .To.Be.False(); }
public void ShouldMakeNewEmptyFolderAvailable() { //---------------Set up test pack------------------- //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- using (var folder = new AutoTempFolder()) { var result = folder.Path; //---------------Test Result ----------------------- Expect(result).Not.To.Be.Null(); Expect(result).To.Be.A.Folder(); var entries = Directory.EnumerateFileSystemEntries(result, "*", SearchOption.AllDirectories); Expect(entries).To.Be.Empty(); } }
public void ShouldBeAbleToInjectEnvironmentVariablesAndCustomWorkingFolder() { // Arrange using var folder = new AutoTempFolder(); var expected = GetRandomAlphaString(4); var envVar = GetRandomAlphaString(4); // Act using var io = ProcessIO .In(folder.Path) .WithEnvironmentVariable(envVar, expected) .Start("pwsh", "-Command", $"Write-Host $env:{envVar}"); // Assert var lines = io.StandardOutput.ToArray().Trim(); Expect(lines) .To.Equal(new[] { expected }); }
public void ListFilesRecursive_SearchPattern_ShouldReturnListOfMatchingFilesInPath() { //---------------Set up test pack------------------- using (var folder = new AutoTempFolder()) { var ext = GetRandomString(3, 3); var otherExt = GetAnother(ext, () => GetRandomString(3, 3)); var matchFiles = GetRandomCollection(() => GetRandomString(2, 4) + "." + ext, 3, 5); var nonMatchFiles = GetRandomCollection(() => GetRandomString(2, 4) + "." + otherExt, 3, 5); var subMatchFiles = new List <string>(); matchFiles.ForEach(f => { var subDirectory = GetRandomString(); Directory.CreateDirectory(Path.Combine(folder.Path, subDirectory)); var subPath = Path.Combine(subDirectory, f); subMatchFiles.Add(subPath); File.WriteAllBytes(Path.Combine(folder.Path, subPath), GetRandomBytes()); }); var subNonMatchFiles = new List <string>(); nonMatchFiles.ForEach(f => { var subDirectory = GetRandomString(); Directory.CreateDirectory(Path.Combine(folder.Path, subDirectory)); var subPath = Path.Combine(subDirectory, f); subNonMatchFiles.Add(subPath); File.WriteAllBytes(Path.Combine(folder.Path, subPath), GetRandomBytes()); }); var unexpected = GetAnother(matchFiles, () => GetRandomString(2, 4) + "." + ext); Directory.CreateDirectory(Path.Combine(folder.Path, unexpected)); var sut = Create(); sut.SetCurrentDirectory(folder.Path); //---------------Assert Precondition---------------- Assert.IsTrue(subMatchFiles.Union(subNonMatchFiles) .All(f => File.Exists(Path.Combine(folder.Path, f)))); //---------------Execute Test ---------------------- var result = sut.ListFilesRecursive("*." + ext); //---------------Test Result ----------------------- Assert.IsTrue(subMatchFiles.All(f => result.Contains(f))); Assert.IsFalse(result.Contains(unexpected)); Assert.IsFalse(subNonMatchFiles.Any(f => result.Contains(f))); } }
public void WhenTargetDatabaseMissing_ShouldAddHistoryTable() { // Arrange using var folder = new AutoTempFolder(); Expect(folder) .Not.To.Have.Contents(); // Act Create(folder); // Assert Expect(folder) .To.Have.Contents(); var dataLayer = new SqLiteDatabase(folder.Path); using var conn = dataLayer.Connect(); Expect(() => conn.Query <HistoryItem>($"select * from {Table.NAME};") ) .Not.To.Throw(); }
public void Dispose_ShouldRemoveEmptyTempFolder() { //---------------Set up test pack------------------- string folderPath; using (var folder = new AutoTempFolder()) { folderPath = folder.Path; //---------------Assert Precondition---------------- Assert.IsNotNull(folderPath); Assert.IsTrue(Directory.Exists(folderPath)); var entries = Directory.EnumerateFileSystemEntries(folderPath, "*", SearchOption.AllDirectories); CollectionAssert.IsEmpty(entries); //---------------Execute Test ---------------------- } //---------------Test Result ----------------------- Assert.IsFalse(Directory.Exists(folderPath)); }
public void GivenCustomBasePath_ShouldUseThatPathAsBaseForTempFolder() { //---------------Set up test pack------------------- var baseFolder = Path.GetDirectoryName(new Uri(Assembly.GetExecutingAssembly().CodeBase).LocalPath); //---------------Assert Precondition---------------- //---------------Execute Test ---------------------- using (var folder = new AutoTempFolder(baseFolder)) { //---------------Test Result ----------------------- Expect(Path.GetDirectoryName( folder.Path )) .To.Equal( baseFolder ); } }