public async Task NullStream_Throws_Async()
{
await using (MemoryStream archiveStream = new MemoryStream())
{
await Assert.ThrowsAsync <ArgumentNullException>(() => TarFile.CreateFromDirectoryAsync(sourceDirectoryName: "path", destination: null, includeBaseDirectory: false));
}
}
public async Task IncludeBaseDirectoryIfEmpty_Async()
{
using (TempDirectory source = new TempDirectory())
using (TempDirectory destination = new TempDirectory())
{
string destinationArchiveFileName = Path.Join(destination.Path, "output.tar");
await TarFile.CreateFromDirectoryAsync(source.Path, destinationArchiveFileName, includeBaseDirectory : true);
FileStreamOptions readOptions = new()
{
Access = FileAccess.Read,
Mode = FileMode.Open,
Options = FileOptions.Asynchronous,
};
await using (FileStream fileStream = File.Open(destinationArchiveFileName, readOptions))
{
await using (TarReader reader = new TarReader(fileStream))
{
TarEntry entry = await reader.GetNextEntryAsync();
Assert.NotNull(entry);
Assert.Equal(TarEntryType.Directory, entry.EntryType);
Assert.Equal(Path.GetFileName(source.Path) + '/', entry.Name);
Assert.Null(await reader.GetNextEntryAsync());
}
}
}
}
public async Task SkipRecursionIntoBaseDirectorySymlinkAsync()
{
using TempDirectory root = new TempDirectory();
string destinationArchive = Path.Join(root.Path, "destination.tar");
string externalDirectory = Path.Join(root.Path, "externalDirectory");
Directory.CreateDirectory(externalDirectory);
string subDirectory = Path.Join(externalDirectory, "subDirectory");
Directory.CreateDirectory(subDirectory);
string sourceDirectoryName = Path.Join(root.Path, "baseDirectory");
Directory.CreateSymbolicLink(sourceDirectoryName, externalDirectory);
await TarFile.CreateFromDirectoryAsync(sourceDirectoryName, destinationArchive, includeBaseDirectory : true); // Base directory is a symlink, do not recurse
await using FileStream archiveStream = File.OpenRead(destinationArchive);
await using TarReader reader = new(archiveStream, leaveOpen : false);
TarEntry entry = await reader.GetNextEntryAsync();
Assert.NotNull(entry);
Assert.Equal("baseDirectory/", entry.Name);
Assert.Equal(TarEntryType.SymbolicLink, entry.EntryType);
Assert.Null(await reader.GetNextEntryAsync()); // subDirectory should not be found
}
public Task CreateFromDirectoryAsync_Cancel()
{
CancellationTokenSource cs = new CancellationTokenSource();
cs.Cancel();
return(Assert.ThrowsAsync <TaskCanceledException>(() => TarFile.CreateFromDirectoryAsync("directory", "file.tar", includeBaseDirectory: false, cs.Token)));
}
public async Task SetsLastModifiedTimeOnExtractedFiles()
{
using TempDirectory root = new TempDirectory();
string inDir = Path.Join(root.Path, "indir");
string inFile = Path.Join(inDir, "file");
string tarFile = Path.Join(root.Path, "file.tar");
string outDir = Path.Join(root.Path, "outdir");
string outFile = Path.Join(outDir, "file");
Directory.CreateDirectory(inDir);
File.Create(inFile).Dispose();
var dt = new DateTime(2001, 1, 2, 3, 4, 5, DateTimeKind.Local);
File.SetLastWriteTime(inFile, dt);
await TarFile.CreateFromDirectoryAsync(sourceDirectoryName : inDir, destinationFileName : tarFile, includeBaseDirectory : false);
Directory.CreateDirectory(outDir);
await TarFile.ExtractToDirectoryAsync(sourceFileName : tarFile, destinationDirectoryName : outDir, overwriteFiles : false);
Assert.True(File.Exists(outFile));
Assert.InRange(File.GetLastWriteTime(outFile).Ticks, dt.AddSeconds(-3).Ticks, dt.AddSeconds(3).Ticks); // include some slop for filesystem granularity
}
public async Task InvalidPath_Throws_Async()
{
await using (MemoryStream archiveStream = new MemoryStream())
{
await Assert.ThrowsAsync <ArgumentNullException>(() => TarFile.CreateFromDirectoryAsync(sourceDirectoryName: null, destination: archiveStream, includeBaseDirectory: false));
await Assert.ThrowsAsync <ArgumentException>(() => TarFile.CreateFromDirectoryAsync(sourceDirectoryName: string.Empty, destination: archiveStream, includeBaseDirectory: false));
}
}
public async Task UnwritableStream_Throws_Async()
{
await using (MemoryStream archiveStream = new MemoryStream())
{
await using (WrappedStream unwritable = new WrappedStream(archiveStream, canRead: true, canWrite: false, canSeek: true))
{
await Assert.ThrowsAsync <IOException>(() => TarFile.CreateFromDirectoryAsync(sourceDirectoryName: "path", destination: unwritable, includeBaseDirectory: false));
}
}
}
public async Task NonExistentDirectory_Throws_Async()
{
using (TempDirectory root = new TempDirectory())
{
string dirPath = Path.Join(root.Path, "dir");
string filePath = Path.Join(root.Path, "file.tar");
await Assert.ThrowsAsync <DirectoryNotFoundException>(() => TarFile.CreateFromDirectoryAsync(sourceDirectoryName: "IDontExist", destinationFileName: filePath, includeBaseDirectory: false));
}
}
public async Task InvalidPaths_Throw_Async()
{
await Assert.ThrowsAsync <ArgumentNullException>(() => TarFile.CreateFromDirectoryAsync(sourceDirectoryName: null, destinationFileName: "path", includeBaseDirectory: false));
await Assert.ThrowsAsync <ArgumentException>(() => TarFile.CreateFromDirectoryAsync(sourceDirectoryName: string.Empty, destinationFileName: "path", includeBaseDirectory: false));
await Assert.ThrowsAsync <ArgumentNullException>(() => TarFile.CreateFromDirectoryAsync(sourceDirectoryName: "path", destinationFileName: null, includeBaseDirectory: false));
await Assert.ThrowsAsync <ArgumentException>(() => TarFile.CreateFromDirectoryAsync(sourceDirectoryName: "path", destinationFileName: string.Empty, includeBaseDirectory: false));
}
public async Task TarGz_TarFile_CreateFromDir_ExtractToDir_Async()
{
using (TempDirectory root = new TempDirectory())
{
string archivePath = Path.Join(root.Path, "compressed.tar.gz");
string sourceDirectory = Path.Join(root.Path, "source");
Directory.CreateDirectory(sourceDirectory);
string destinationDirectory = Path.Join(root.Path, "destination");
Directory.CreateDirectory(destinationDirectory);
string fileName = "file.txt";
string filePath = Path.Join(sourceDirectory, fileName);
File.Create(filePath).Dispose();
FileStreamOptions createOptions = new()
{
Mode = FileMode.CreateNew,
Access = FileAccess.Write,
Options = FileOptions.Asynchronous
};
await using (FileStream streamToCompress = File.Open(archivePath, createOptions))
{
await using (GZipStream compressorStream = new GZipStream(streamToCompress, CompressionMode.Compress))
{
await TarFile.CreateFromDirectoryAsync(sourceDirectory, compressorStream, includeBaseDirectory : false);
}
}
FileInfo fileInfo = new FileInfo(archivePath);
Assert.True(fileInfo.Exists);
Assert.True(fileInfo.Length > 0);
FileStreamOptions readOptions = new()
{
Mode = FileMode.Open,
Access = FileAccess.Read,
Options = FileOptions.Asynchronous
};
await using (FileStream streamToDecompress = File.Open(archivePath, readOptions))
{
await using (GZipStream decompressorStream = new GZipStream(streamToDecompress, CompressionMode.Decompress))
{
await TarFile.ExtractToDirectoryAsync(decompressorStream, destinationDirectory, overwriteFiles : true);
Assert.True(File.Exists(filePath));
}
}
}
}
}
}
public async Task CreateFromDirectoryAsync_Cancel()
{
CancellationTokenSource cs = new CancellationTokenSource();
cs.Cancel();
await using (MemoryStream archiveStream = new MemoryStream())
{
await Assert.ThrowsAsync <TaskCanceledException>(() => TarFile.CreateFromDirectoryAsync("directory", archiveStream, includeBaseDirectory: false, cs.Token));
}
}
public async Task NonExistentDirectory_Throws_Async()
{
using (TempDirectory root = new TempDirectory())
{
string dirPath = Path.Join(root.Path, "dir");
await using (MemoryStream archive = new MemoryStream())
{
await Assert.ThrowsAsync <DirectoryNotFoundException>(() => TarFile.CreateFromDirectoryAsync(sourceDirectoryName: dirPath, destination: archive, includeBaseDirectory: false));
}
}
}
public async Task IncludeAllSegmentsOfPath_Async(bool includeBaseDirectory)
{
using (TempDirectory source = new TempDirectory())
using (TempDirectory destination = new TempDirectory())
{
string segment1 = Path.Join(source.Path, "segment1");
Directory.CreateDirectory(segment1);
string segment2 = Path.Join(segment1, "segment2");
Directory.CreateDirectory(segment2);
string textFile = Path.Join(segment2, "file.txt");
File.Create(textFile).Dispose();
string destinationArchiveFileName = Path.Join(destination.Path, "output.tar");
await TarFile.CreateFromDirectoryAsync(source.Path, destinationArchiveFileName, includeBaseDirectory);
FileStreamOptions readOptions = new()
{
Access = FileAccess.Read,
Mode = FileMode.Open,
Options = FileOptions.Asynchronous,
};
await using (FileStream fileStream = File.Open(destinationArchiveFileName, readOptions))
{
await using (TarReader reader = new TarReader(fileStream))
{
string prefix = includeBaseDirectory ? Path.GetFileName(source.Path) + '/' : string.Empty;
TarEntry entry = await reader.GetNextEntryAsync();
Assert.NotNull(entry);
Assert.Equal(TarEntryType.Directory, entry.EntryType);
Assert.Equal(prefix + "segment1/", entry.Name);
entry = await reader.GetNextEntryAsync();
Assert.NotNull(entry);
Assert.Equal(TarEntryType.Directory, entry.EntryType);
Assert.Equal(prefix + "segment1/segment2/", entry.Name);
entry = await reader.GetNextEntryAsync();
Assert.NotNull(entry);
Assert.Equal(TarEntryType.RegularFile, entry.EntryType);
Assert.Equal(prefix + "segment1/segment2/file.txt", entry.Name);
Assert.Null(await reader.GetNextEntryAsync());
}
}
}
}
public async Task DestinationExists_Throws_Async()
{
using (TempDirectory root = new TempDirectory())
{
string dirPath = Path.Join(root.Path, "dir");
Directory.CreateDirectory(dirPath);
string filePath = Path.Join(root.Path, "file.tar");
File.Create(filePath).Dispose();
await Assert.ThrowsAsync <IOException>(() => TarFile.CreateFromDirectoryAsync(sourceDirectoryName: dirPath, destinationFileName: filePath, includeBaseDirectory: false));
}
}
