public virtual async Task UploadPartitionSuccessfulHashComputation(TransactionalHashAlgorithm algorithm)
{
await using IDisposingContainer <TContainerClient> disposingContainer = await GetDisposingContainerAsync();
// Arrange
const int dataLength = Constants.KB;
var data = GetRandomBuffer(dataLength);
var hashingOptions = new UploadTransactionalHashingOptions
{
Algorithm = algorithm
};
// make pipeline assertion for checking hash was present on upload
var hashPipelineAssertion = new AssertMessageContentsPolicy(checkRequest: GetRequestHashAssertion(algorithm));
var clientOptions = ClientBuilder.GetOptions();
clientOptions.AddPolicy(hashPipelineAssertion, HttpPipelinePosition.PerCall);
var client = await GetResourceClientAsync(
disposingContainer.Container,
resourceLength : dataLength,
createResource : true,
options : clientOptions);
// Act
using (var stream = new MemoryStream(data))
{
hashPipelineAssertion.CheckRequest = true;
await UploadPartitionAsync(client, stream, hashingOptions);
}
// Assert
// Assertion was in the pipeline and the service returning success means the hash was correct
}
public virtual async Task OpenReadSuccessfulHashVerification(
[Values(TransactionalHashAlgorithm.MD5, TransactionalHashAlgorithm.StorageCrc64)] TransactionalHashAlgorithm algorithm,
[Values(
// multiple reads that neatly align
Constants.KB,
// multiple reads with final having leftover buffer space
2 * Constants.KB,
// buffer larger than data
4 * Constants.KB)] int bufferSize)
{
await using IDisposingContainer <TContainerClient> disposingContainer = await GetDisposingContainerAsync();
// Arrange
// bufferSize/datasize MUST be a multiple of 512 for pageblob tests
const int dataLength = 3 * Constants.KB;
var data = GetRandomBuffer(dataLength);
var resourceName = GetNewResourceName();
var client = await GetResourceClientAsync(
disposingContainer.Container,
resourceLength : dataLength,
createResource : true,
resourceName : resourceName);
await SetupDataAsync(client, new MemoryStream(data));
// make pipeline assertion for checking hash was present on download
var hashPipelineAssertion = new AssertMessageContentsPolicy(checkResponse: GetResponseHashAssertion(algorithm));
var clientOptions = ClientBuilder.GetOptions();
clientOptions.AddPolicy(hashPipelineAssertion, HttpPipelinePosition.PerCall);
client = await GetResourceClientAsync(
disposingContainer.Container,
createResource : false,
resourceName : resourceName,
options : clientOptions);
var hashingOptions = new DownloadTransactionalHashingOptions {
Algorithm = algorithm
};
// Act
var readStream = await OpenReadAsync(client, hashingOptions, bufferSize);
// Assert
hashPipelineAssertion.CheckResponse = true;
await DoesNotThrowOrInconclusiveAsync(async() => await readStream.CopyToAsync(Stream.Null));
}
public virtual async Task ParallelDownloadSuccessfulHashVerification(
[Values(TransactionalHashAlgorithm.MD5, TransactionalHashAlgorithm.StorageCrc64)] TransactionalHashAlgorithm algorithm,
[Values(512, 2 * Constants.KB)] int chunkSize)
{
await using IDisposingContainer <TContainerClient> disposingContainer = await GetDisposingContainerAsync();
// Arrange
const int dataLength = 2 * Constants.KB;
var data = GetRandomBuffer(dataLength);
var resourceName = GetNewResourceName();
var client = await GetResourceClientAsync(
disposingContainer.Container,
resourceLength : dataLength,
createResource : true,
resourceName : resourceName);
await SetupDataAsync(client, new MemoryStream(data));
// make pipeline assertion for checking hash was present on download
var hashPipelineAssertion = new AssertMessageContentsPolicy(checkResponse: GetResponseHashAssertion(algorithm));
var clientOptions = ClientBuilder.GetOptions();
clientOptions.AddPolicy(hashPipelineAssertion, HttpPipelinePosition.PerCall);
client = await GetResourceClientAsync(
disposingContainer.Container,
createResource : false,
resourceName : resourceName,
options : clientOptions);
var hashingOptions = new DownloadTransactionalHashingOptions {
Algorithm = algorithm
};
StorageTransferOptions transferOptions = new StorageTransferOptions
{
InitialTransferSize = chunkSize,
MaximumTransferSize = chunkSize
};
// Act
hashPipelineAssertion.CheckResponse = true;
await ParallelDownloadAsync(client, Stream.Null, hashingOptions, transferOptions);
// Assert
// Assertion was in the pipeline and the SDK not throwing means the hash was validated
}
public virtual async Task UploadPartitionUsePrecalculatedHash(TransactionalHashAlgorithm algorithm)
{
await using IDisposingContainer <TContainerClient> disposingContainer = await GetDisposingContainerAsync();
// Arrange
const int dataLength = Constants.KB;
var data = GetRandomBuffer(dataLength);
// service throws different error for crc only when hash size in incorrect; we don't want to test that
var hashSizeBytes = algorithm switch
{
TransactionalHashAlgorithm.MD5 => 16,
TransactionalHashAlgorithm.StorageCrc64 => 8,
_ => throw new ArgumentException("Cannot determine hash size for provided algorithm type")
};
// hash needs to be wrong so we detect difference from auto-SDK correct calculation
var precalculatedHash = GetRandomBuffer(hashSizeBytes);
var hashingOptions = new UploadTransactionalHashingOptions
{
Algorithm = algorithm,
PrecalculatedHash = precalculatedHash
};
// make pipeline assertion for checking precalculated hash was present on upload
var hashPipelineAssertion = new AssertMessageContentsPolicy(checkRequest: GetRequestHashAssertion(algorithm, expectedHash: precalculatedHash));
var clientOptions = ClientBuilder.GetOptions();
clientOptions.AddPolicy(hashPipelineAssertion, HttpPipelinePosition.PerCall);
var client = await GetResourceClientAsync(
disposingContainer.Container,
resourceLength : dataLength,
createResource : true,
options : clientOptions);
hashPipelineAssertion.CheckRequest = true;
using (var stream = new MemoryStream(data))
{
// Act
AsyncTestDelegate operation = async() => await UploadPartitionAsync(client, stream, hashingOptions);
// Assert
AssertWriteHashMismatch(operation, algorithm);
}
}
public async Task RoundtripWIthDefaults()
{
await using IDisposingContainer <TContainerClient> disposingContainer = await GetDisposingContainerAsync();
// Arrange
const TransactionalHashAlgorithm expectedAlgorithm = TransactionalHashAlgorithm.StorageCrc64;
const int dataLength = Constants.KB;
var data = GetRandomBuffer(dataLength);
var uploadHashingOptions = new UploadTransactionalHashingOptions();
var downloadHashingOptions = new DownloadTransactionalHashingOptions();
var clientOptions = ClientBuilder.GetOptions();
StorageTransferOptions transferOptions = new StorageTransferOptions
{
InitialTransferSize = 512,
MaximumTransferSize = 512
};
// make pipeline assertion for checking hash was present on upload AND download
var hashPipelineAssertion = new AssertMessageContentsPolicy(
checkRequest: GetRequestHashAssertion(expectedAlgorithm, isHashExpected: ParallelUploadIsHashExpected),
checkResponse: GetResponseHashAssertion(expectedAlgorithm));
clientOptions.AddPolicy(hashPipelineAssertion, HttpPipelinePosition.PerCall);
var client = await GetResourceClientAsync(disposingContainer.Container, resourceLength : dataLength, createResource : true, options : clientOptions);
// Act
using (var stream = new MemoryStream(data))
{
hashPipelineAssertion.CheckRequest = true;
await ParallelUploadAsync(client, stream, uploadHashingOptions, transferOptions);
hashPipelineAssertion.CheckRequest = false;
}
hashPipelineAssertion.CheckResponse = true;
await ParallelDownloadAsync(client, Stream.Null, downloadHashingOptions, transferOptions);
// Assert
// Assertion was in the pipeline and the service returning success means the hash was correct
}
public virtual async Task OpenWriteSuccessfulHashComputation(TransactionalHashAlgorithm algorithm)
{
await using IDisposingContainer <TContainerClient> disposingContainer = await GetDisposingContainerAsync();
// Arrange
const int streamBufferSize = Constants.KB; // this one needs to be 512 multiple for page blobs
const int dataSize = Constants.KB - 11; // odd number to get some variance
const int streamWrites = 10;
var data = GetRandomBuffer(dataSize);
var hashingOptions = new UploadTransactionalHashingOptions
{
Algorithm = algorithm
};
// make pipeline assertion for checking hash was present on upload
var hashPipelineAssertion = new AssertMessageContentsPolicy(checkRequest: GetRequestHashAssertion(algorithm));
var clientOptions = ClientBuilder.GetOptions();
clientOptions.AddPolicy(hashPipelineAssertion, HttpPipelinePosition.PerCall);
var client = await GetResourceClientAsync(
disposingContainer.Container,
// should use dataSize instead of streamBufferSize but this gives 512 multiple and ends up irrelevant for this test
resourceLength : streamBufferSize *streamWrites,
createResource : true,
options : clientOptions);
// Act
var writeStream = await OpenWriteAsync(client, hashingOptions, streamBufferSize);
// Assert
hashPipelineAssertion.CheckRequest = true;
foreach (var _ in Enumerable.Range(0, streamWrites))
{
// triggers pipeline assertion
await writeStream.WriteAsync(data, 0, data.Length);
}
}
