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