public async Task AllowsReadingOfZipCentralDirectory(string path)
{
// Arrange
var originalStream = TestUtility.BufferTestData(path);
var result = await TestUtility.ReadWithMiniZipAsync(originalStream);
var expected = result.Data;
var innerStream = new MemoryStream();
var prefix = new byte[2345];
var suffix = new byte[6789];
innerStream.Write(prefix, 0, prefix.Length);
originalStream.Position = 0;
await originalStream.CopyToAsync(innerStream);
innerStream.Write(suffix, 0, suffix.Length);
var target = new BoundedStream(innerStream, prefix.Length, (prefix.Length + originalStream.Length) - 1);
var reader = new ZipDirectoryReader(target);
var expectedSize = originalStream.Length;
// Act
var actual = await reader.ReadAsync();
// Assert
TestUtility.VerifyJsonEquals(expected, actual);
Assert.Equal(expectedSize, target.Length);
Assert.Equal(prefix.Length + target.Length + suffix.Length, innerStream.Length);
}
public async Task UsesETagWhenRequiringAnETag()
{
// Arrange
var fileName = "System.IO.Compression/refzipfiles/normal.zip";
using (var server = TestUtility.GetTestServer(TestUtility.TestDataDirectory))
using (var client = server.CreateClient())
{
var requestUri = new Uri(new Uri(server.BaseAddress, TestUtility.TestServerDirectory + "/"), fileName);
var target = new HttpZipProvider(client)
{
ETagBehavior = ETagBehavior.Required
};
// Act
var reader = await target.GetReaderAsync(requestUri);
// Assert
var actual = await reader.ReadAsync();
var expected = await TestUtility.ReadWithMiniZipAsync(TestUtility.BufferTestData(fileName));
TestUtility.VerifyJsonEquals(expected.Data, actual);
}
}
public async Task CanReadFromAChangedStream()
{
// Arrange
using (var streamA = TestUtility.BufferTestData(@"System.IO.Compression\refzipfiles\normal.zip"))
using (var streamB = TestUtility.BufferTestData(@"System.IO.Compression\refzipfiles\small.zip"))
using (var sourceStream = new MemoryStream())
{
var expected = (await TestUtility.ReadWithMiniZipAsync(streamB)).Data;
await streamA.CopyToAsync(sourceStream);
var reader = new ZipDirectoryReader(sourceStream);
await reader.ReadAsync();
sourceStream.SetLength(0);
streamB.Position = 0;
await streamB.CopyToAsync(sourceStream);
// Act
var actual = await reader.ReadAsync();
// Assert
Assert.NotSame(expected, actual);
TestUtility.VerifyJsonEquals(expected, actual);
}
}
public async Task AllowsReadingOfZipCentralDirectory(string path)
{
// Arrange
var originalStream = TestUtility.BufferTestData(path);
var result = await TestUtility.ReadWithMiniZipAsync(originalStream);
var expected = result.Data;
var innerStream = new MemoryStream();
var virtualOffset = (long)(expected.Zip64?.OffsetOfCentralDirectory ?? expected.OffsetOfCentralDirectory);
originalStream.Position = virtualOffset;
await originalStream.CopyToAsync(innerStream);
var target = new VirtualOffsetStream(innerStream, virtualOffset);
var reader = new ZipDirectoryReader(target);
var expectedSize = originalStream.Length - virtualOffset;
// Act
var actual = await reader.ReadAsync();
// Assert
TestUtility.VerifyJsonEquals(expected, actual);
Assert.Equal(expectedSize, innerStream.Length);
Assert.Equal(originalStream.Length, target.Length);
}
public async Task WithSelfUsingHttpRangeReader(string path)
{
// Arrange
using (var memoryStream = TestUtility.BufferTestData(path))
using (var server = TestUtility.GetTestServer(TestUtility.TestDataDirectory))
using (var client = server.CreateClient())
{
var httpZipProvider = new HttpZipProvider(client)
{
ETagBehavior = ETagBehavior.Required,
FirstBufferSize = 1,
SecondBufferSize = 1,
BufferGrowthExponent = 2,
};
var requestUri = new Uri(new Uri(server.BaseAddress, TestUtility.TestServerDirectory + "/"), path);
using (var bufferedRangeStream = await httpZipProvider.GetStreamAsync(requestUri))
{
// Act
var a = await TestUtility.ReadWithMiniZipAsync(memoryStream);
var b = await TestUtility.ReadWithMiniZipAsync(bufferedRangeStream);
// Assert
TestUtility.VerifyJsonEquals(a.Data, b.Data);
Assert.Equal(a.Success, b.Success);
Assert.Equal(a.Exception?.Message, b.Exception?.Message);
Assert.Equal(a.Exception?.GetType(), b.Exception?.GetType());
}
}
}
public async Task HandlesChangingETagProperly(ETagBehavior etagBehavior, bool success)
{
// Arrange
using (var directory = TestDirectory.Create())
{
var fileName = "normal.zip";
var serverDir = Path.Combine(directory, TestUtility.TestServerDirectory);
var filePath = Path.Combine(serverDir, fileName);
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
using (var server = TestUtility.GetTestServer(
serverDir,
etags: true,
middleware: async(context, next) =>
{
await next.Invoke();
File.SetLastWriteTimeUtc(filePath, DateTime.UtcNow);
}))
using (var client = server.CreateClient())
{
File.Copy(
Path.Combine(TestUtility.TestDataDirectory, "System.IO.Compression/refzipfiles/normal.zip"),
filePath);
var requestUri = new Uri(new Uri(server.BaseAddress, TestUtility.TestServerDirectory + "/"), fileName);
var target = new HttpZipProvider(client)
{
ETagBehavior = etagBehavior
};
var reader = await target.GetReaderAsync(requestUri);
// Act & Assert
if (success)
{
var actual = await reader.ReadAsync();
var expected = await TestUtility.ReadWithMiniZipAsync(TestUtility.BufferTestData(filePath));
TestUtility.VerifyJsonEquals(expected.Data, actual);
}
else
{
var ex = await Assert.ThrowsAsync <MiniZipHttpException>(() => reader.ReadAsync());
Assert.StartsWith(
"The HTTP response did not have the expected status code HTTP 206 Partial Content. The response was 412 Precondition Failed.",
ex.Message);
Assert.Equal(HttpStatusCode.PreconditionFailed, ex.StatusCode);
Assert.Equal("Precondition Failed", ex.ReasonPhrase);
Assert.StartsWith("HTTP/", ex.DebugResponse);
}
}
}
}
public async Task CanGatherAndRecreateNuGetPackageCentralDirectory()
{
using (var testDirectory = TestDirectory.Create())
{
// Discover the .nupkg URL.
var sourceRepository = Repository.Factory.GetCoreV3("https://api.nuget.org/v3/index.json");
var serviceIndex = await sourceRepository.GetResourceAsync <ServiceIndexResourceV3>();
var packageBaseAddress = serviceIndex.GetServiceEntryUri(ServiceTypes.PackageBaseAddress);
var id = "Newtonsoft.Json".ToLowerInvariant();
var version = NuGetVersion.Parse("9.0.1").ToNormalizedString().ToLowerInvariant();
var packageUri = new Uri(packageBaseAddress, $"{id}/{version}/{id}.{version}.nupkg");
ZipDirectory zipDirectoryA;
string mzipPath;
using (var httpClient = new HttpClient())
{
var httpZipProvider = new HttpZipProvider(httpClient);
using (var reader = await httpZipProvider.GetReaderAsync(packageUri))
{
// Read the ZIP directory from the .nupkg URL.
zipDirectoryA = await reader.ReadAsync();
// Save the .mzip to the test directory.
mzipPath = Path.Combine(testDirectory, $"{id}.{version}.mzip");
using (var fileStream = new FileStream(mzipPath, FileMode.Create))
{
var mzipFormat = new MZipFormat();
await mzipFormat.WriteAsync(reader.Stream, fileStream);
}
}
}
// Read the .mzip back from disk.
ZipDirectory zipDirectoryB;
using (var fileStream = new FileStream(mzipPath, FileMode.Open))
{
var mzipFormat = new MZipFormat();
using (var mzipStream = await mzipFormat.ReadAsync(fileStream))
using (var reader = new ZipDirectoryReader(mzipStream))
{
zipDirectoryB = await reader.ReadAsync();
}
}
// Compare the results.
TestUtility.VerifyJsonEquals(zipDirectoryA, zipDirectoryB);
}
}
public async Task DoesNotReadBeforeCentralDirectory(string path, long minimum, long maximum)
{
// Arrange
using (var originalStream = TestUtility.BufferTestData(path))
using (var stream = new MinimumPositionStream(originalStream))
{
var expected = await TestUtility.ReadWithMiniZipAsync(originalStream);
// Act
var actual = await TestUtility.ReadWithMiniZipAsync(stream);
// Assert
TestUtility.VerifyJsonEquals(expected, actual);
Assert.Equal(minimum, stream.MinimumPositionRead);
Assert.Equal(maximum, stream.MaximumPositionRead);
}
}
public async Task AllowsReadingTwice()
{
// Arrange
using (var stream = TestUtility.BufferTestData(@"System.IO.Compression\refzipfiles\normal.zip"))
{
var reader = new ZipDirectoryReader(stream);
// Act
var outputA = await reader.ReadAsync();
var outputB = await reader.ReadAsync();
// Assert
Assert.NotSame(outputA, outputB);
TestUtility.VerifyJsonEquals(outputA, outputB);
}
}
public async Task CanGatherAndRecreateNuGetPackageCentralDirectory(string id, string version)
{
using (var testDirectory = TestDirectory.Create())
{
var packageUri = await NuGetUtility.GetNupkgUrlAsync(id, version);
ZipDirectory zipDirectoryA;
string mzipPath;
using (var httpClient = new HttpClient())
{
var httpZipProvider = new HttpZipProvider(httpClient)
{
RequireAcceptRanges = false,
};
using (var reader = await httpZipProvider.GetReaderAsync(packageUri))
{
// Read the ZIP directory from the .nupkg URL.
zipDirectoryA = await reader.ReadAsync();
// Save the .mzip to the test directory.
mzipPath = Path.Combine(testDirectory, $"{id}.{version}.mzip");
using (var fileStream = new FileStream(mzipPath, FileMode.Create))
{
var mzipFormat = new MZipFormat();
await mzipFormat.WriteAsync(reader.Stream, fileStream);
}
}
}
// Read the .mzip back from disk.
ZipDirectory zipDirectoryB;
using (var fileStream = new FileStream(mzipPath, FileMode.Open))
{
var mzipFormat = new MZipFormat();
using (var mzipStream = await mzipFormat.ReadAsync(fileStream))
using (var reader = new ZipDirectoryReader(mzipStream))
{
zipDirectoryB = await reader.ReadAsync();
}
}
// Compare the results.
TestUtility.VerifyJsonEquals(zipDirectoryA, zipDirectoryB);
}
}
public async Task CanRoundTripZipFile(string path)
{
// Arrange
var srcStream = TestUtility.BufferTestData(path);
var expected = (await TestUtility.ReadWithMiniZipAsync(srcStream)).Data;
var target = new MZipFormat();
var dstStream = new MemoryStream();
// Act
await target.WriteAsync(srcStream, dstStream);
dstStream.Position = 0;
var mzipStream = await target.ReadAsync(dstStream);
var actual = (await TestUtility.ReadWithMiniZipAsync(mzipStream)).Data;
// Assert
TestUtility.VerifyJsonEquals(expected, actual);
}
public async Task WithSelfUsingFileRangeReader(string path)
{
// Arrange
using (var memoryStream = TestUtility.BufferTestData(path))
{
var fullPath = Path.Combine(TestUtility.TestDataDirectory, path);
var length = new FileInfo(fullPath).Length;
var fileRangeReader = new FileRangeReader(fullPath);
var bufferSizeProvider = new ZipBufferSizeProvider(firstBufferSize: 1, secondBufferSize: 1, exponent: 2);
using (var bufferedRangeStream = new BufferedRangeStream(fileRangeReader, length, bufferSizeProvider))
{
// Act
var a = await TestUtility.ReadWithMiniZipAsync(memoryStream);
var b = await TestUtility.ReadWithMiniZipAsync(bufferedRangeStream);
// Assert
TestUtility.VerifyJsonEquals(a.Data, b.Data);
Assert.Equal(a.Success, b.Success);
Assert.Equal(a.Exception?.Message, b.Exception?.Message);
Assert.Equal(a.Exception?.GetType(), b.Exception?.GetType());
}
}
}