public async Task Batch_CanUseResponseAfterException()
{
await using TestScenario scenario = Scenario();
Uri[] good = await scenario.CreateBlobUrisAsync(1);
Uri[] bad = scenario.GetInvalidBlobUris(1);
BlobBatchClient client = scenario.GetBlobBatchClient();
using BlobBatch batch = client.CreateBatch();
Response response1 = batch.DeleteBlob(good[0]);
Response response2 = batch.DeleteBlob(bad[0]);
try
{
await client.SubmitBatchAsync(batch);
}
catch (AggregateException)
{
// Swallow the exception
}
scenario.AssertStatus(202, response1);
scenario.AssertStatus(404, response2);
}
public void Batch_StatusIndicatesCannotRead()
{
using TestScenario scenario = Scenario();
Uri uri = scenario.GetInvalidBlobUris(1)[0];
BlobBatchClient client = scenario.GetBlobBatchClient();
BlobBatch batch = client.CreateBatch();
Response response = batch.DeleteBlob(uri);
Assert.AreEqual(0, response.Status);
}
public void Batch_CannotReadBeforeSubmit()
{
using TestScenario scenario = Scenario();
Uri uri = scenario.GetInvalidBlobUris(1)[0];
BlobBatchClient client = scenario.GetBlobBatchClient();
BlobBatch batch = client.CreateBatch();
Response response = batch.DeleteBlob(uri);
InvalidOperationException ex = Assert.Throws <InvalidOperationException>(
() => { var _ = response.ClientRequestId; });
StringAssert.Contains("Cannot use the Response before calling BlobBatchClient.SubmitBatch", ex.Message);
}
public void Batch_EmptyFails()
{
TestDiagnostics = false;
using TestScenario scenario = Scenario();
BlobBatchClient client = scenario.GetBlobBatchClient();
BlobBatch batch = client.CreateBatch();
ArgumentException ex = Assert.ThrowsAsync <ArgumentException>(
async() => await client.SubmitBatchAsync(batch));
StringAssert.Contains("Cannot submit an empty batch", ex.Message);
}
public void Batch_Homogenous_SetTier()
{
using TestScenario scenario = Scenario();
Uri[] uris = scenario.GetInvalidBlobUris(2);
BlobBatchClient client = scenario.GetBlobBatchClient();
BlobBatch batch = client.CreateBatch();
batch.SetBlobAccessTier(uris[0], AccessTier.Cool);
InvalidOperationException ex = Assert.Throws <InvalidOperationException>(
() => batch.DeleteBlob(uris[1]));
StringAssert.Contains("already being used for SetAccessTier operations", ex.Message);
}
public async Task Delete_Basic_Convenience()
{
await using TestScenario scenario = Scenario();
BlobClient[] blobs = await scenario.CreateBlobsAsync(3);
Uri[] uris = blobs.Select(b => b.Uri).ToArray();
BlobBatchClient client = scenario.GetBlobBatchClient();
Response[] responses = await client.DeleteBlobsAsync(uris);
scenario.AssertStatus(202, responses);
await scenario.AssertDeleted(blobs);
}
public async Task SetBlobAccessTier_Basic_Convenience()
{
await using TestScenario scenario = Scenario();
BlobClient[] blobs = await scenario.CreateBlobsAsync(3);
Uri[] uris = blobs.Select(b => b.Uri).ToArray();
BlobBatchClient client = scenario.GetBlobBatchClient();
Response[] responses = await client.SetBlobsAccessTierAsync(uris, AccessTier.Cool);
scenario.AssertStatus(200, responses);
await scenario.AssertTiers(AccessTier.Cool, blobs);
}
public async Task Batch_Homogenous_Delete()
{
await using TestScenario scenario = Scenario();
Uri[] uris = scenario.GetInvalidBlobUris(2);
BlobBatchClient client = scenario.GetBlobBatchClient();
using BlobBatch batch = client.CreateBatch();
batch.DeleteBlob(uris[0]);
InvalidOperationException ex = Assert.Throws <InvalidOperationException>(
() => batch.SetBlobAccessTier(uris[1], AccessTier.Cool));
batch.Dispose();
StringAssert.Contains("already being used for Delete operations", ex.Message);
}
public async Task Batch_SasUri_NotOwner()
{
// Create a container using SAS for Auth
string containerName = GetNewContainerName();
await using DisposingContainer test = await GetTestContainerAsync();
await using TestScenario scenario = Scenario(GetServiceClient_BlobServiceSas_Container(containerName));
Uri[] blobs = await scenario.CreateBlobUrisAsync(test.Container, 2);
BlobBatchClient client = scenario.GetBlobBatchClient();
RequestFailedException ex = Assert.ThrowsAsync <RequestFailedException>(
async() => await client.DeleteBlobsAsync(blobs));
Assert.AreEqual(403, ex.Status);
}
public async Task SetBlobAccessTier_MultipleFail_Convenience()
{
await using TestScenario scenario = Scenario();
BlobClient[] good = await scenario.CreateBlobsAsync(1);
Uri[] bad = scenario.GetInvalidBlobUris(2);
Uri[] uris = good.Select(b => b.Uri).Concat(bad).ToArray();
BlobBatchClient client = scenario.GetBlobBatchClient();
AggregateException exes = Assert.ThrowsAsync <AggregateException>(
async() => await client.SetBlobsAccessTierAsync(uris, AccessTier.Cool));
Assert.AreEqual(2, exes.InnerExceptions.Count);
Assert.AreEqual(404, (exes.InnerExceptions[0] as RequestFailedException)?.Status);
Assert.AreEqual(404, (exes.InnerExceptions[1] as RequestFailedException)?.Status);
await scenario.AssertTiers(AccessTier.Cool, good);
}
public async Task Batch_Limit()
{
await using TestScenario scenario = Scenario();
Uri[] blobs = await scenario.CreateBlobUrisAsync(257);
BlobBatchClient client = scenario.GetBlobBatchClient();
// One over the limit
RequestFailedException ex = Assert.ThrowsAsync <RequestFailedException>(
async() => await client.DeleteBlobsAsync(blobs));
Assert.AreEqual(400, ex.Status);
Assert.AreEqual("ExceedsMaxBatchRequestCount", ex.ErrorCode);
// The exact limit
await client.DeleteBlobsAsync(blobs.Take(256).ToArray());
}
public void Batch_CannotChangeClients()
{
TestDiagnostics = false;
using TestScenario scenario1 = Scenario();
BlobBatchClient client1 = scenario1.GetBlobBatchClient();
Uri uri = scenario1.GetInvalidBlobUris(1)[0];
BlobBatch batch1 = client1.CreateBatch();
Response response = batch1.DeleteBlob(uri);
using TestScenario scenario2 = Scenario();
BlobBatchClient client2 = scenario2.GetBlobBatchClient();
ArgumentException ex = Assert.ThrowsAsync <ArgumentException>(
async() => await client2.SubmitBatchAsync(batch1));
StringAssert.Contains("BlobBatchClient used to create the BlobBatch must be used to submit it", ex.Message);
}
public async Task Delete_MultipleFail_NoThrow()
{
using TestScenario scenario = Scenario();
BlobClient[] good = await scenario.CreateBlobsAsync(1);
Uri[] bad = scenario.GetInvalidBlobUris(2);
BlobBatchClient client = scenario.GetBlobBatchClient();
BlobBatch batch = client.CreateBatch();
Response response1 = batch.DeleteBlob(good[0].Uri);
Response response2 = batch.DeleteBlob(bad[0]);
Response response3 = batch.DeleteBlob(bad[1]);
Response response = await client.SubmitBatchAsync(batch, throwOnFailure : false);
scenario.AssertStatus(202, response, response1);
scenario.AssertStatus(404, response2, response3);
await scenario.AssertDeleted(good);
}
public async Task Batch_AzureSasCredential()
{
// Create a container using SAS for Auth
await using DisposingContainer test = await GetTestContainerAsync();
var serviceClient = GetServiceClient_SharedKey();
var sas = GetAccountSasCredentials().SasToken;
var sasServiceClient = InstrumentClient(new BlobServiceClient(serviceClient.Uri, new AzureSasCredential(sas), GetOptions()));
await using TestScenario scenario = Scenario(sasServiceClient);
Uri[] blobs = await scenario.CreateBlobUrisAsync(test.Container, 2);
BlobBatchClient client = scenario.GetBlobBatchClient();
Response[] responses = await client.DeleteBlobsAsync(blobs);
scenario.AssertStatus(202, responses);
}
public async Task Batch_AcrossContainers()
{
await using TestScenario scenario = Scenario();
BlobContainerClient container1 = await scenario.CreateContainerAsync();
Uri[] blobs1 = await scenario.CreateBlobUrisAsync(container1, 2);
BlobContainerClient container2 = await scenario.CreateContainerAsync();
Uri[] blobs2 = await scenario.CreateBlobUrisAsync(container2, 3);
Uri[] blobs = blobs1.Concat(blobs2).ToArray();
BlobBatchClient client = scenario.GetBlobBatchClient();
Response[] responses = await client.DeleteBlobsAsync(blobs);
scenario.AssertStatus(202, responses);
}
public async Task SetBlobAccessTier_MultipleFail_NoThrow()
{
using TestScenario scenario = Scenario();
BlobClient[] good = await scenario.CreateBlobsAsync(1);
Uri[] bad = scenario.GetInvalidBlobUris(2);
BlobBatchClient client = scenario.GetBlobBatchClient();
BlobBatch batch = client.CreateBatch();
Response response1 = batch.SetBlobAccessTier(good[0].Uri, AccessTier.Cool);
Response response2 = batch.SetBlobAccessTier(bad[0], AccessTier.Cool);
Response response3 = batch.SetBlobAccessTier(bad[1], AccessTier.Cool);
Response response = await client.SubmitBatchAsync(batch, throwOnFailure : false);
scenario.AssertStatus(202, response);
scenario.AssertStatus(200, response1);
scenario.AssertStatus(404, response2, response3);
await scenario.AssertTiers(AccessTier.Cool, good);
}
public async Task SetBlobAccessTier_Basic()
{
await using TestScenario scenario = Scenario();
BlobClient[] blobs = await scenario.CreateBlobsAsync(3);
BlobBatchClient client = scenario.GetBlobBatchClient();
using BlobBatch batch = client.CreateBatch();
Response[] responses = new Response[]
{
batch.SetBlobAccessTier(blobs[0].Uri, AccessTier.Cool),
batch.SetBlobAccessTier(blobs[1].Uri, AccessTier.Cool),
batch.SetBlobAccessTier(blobs[2].Uri, AccessTier.Cool)
};
Response response = await client.SubmitBatchAsync(batch);
scenario.AssertStatus(202, response);
scenario.AssertStatus(200, responses);
await scenario.AssertTiers(AccessTier.Cool, blobs);
}
public async Task SetBlobAccessTier_MultipleFail()
{
using TestScenario scenario = Scenario();
BlobClient[] good = await scenario.CreateBlobsAsync(1);
Uri[] bad = scenario.GetInvalidBlobUris(2);
BlobBatchClient client = scenario.GetBlobBatchClient();
BlobBatch batch = client.CreateBatch();
Response response1 = batch.SetBlobAccessTier(good[0].Uri, AccessTier.Cool);
Response response2 = batch.SetBlobAccessTier(bad[0], AccessTier.Cool);
Response response3 = batch.SetBlobAccessTier(bad[1], AccessTier.Cool);
AggregateException exes = Assert.ThrowsAsync <AggregateException>(
async() => await client.SubmitBatchAsync(batch));
Assert.AreEqual(2, exes.InnerExceptions.Count);
Assert.AreEqual(404, (exes.InnerExceptions[0] as RequestFailedException)?.Status);
Assert.AreEqual(404, (exes.InnerExceptions[1] as RequestFailedException)?.Status);
await scenario.AssertTiers(AccessTier.Cool, good);
}
public async Task Delete_OneFails_NoThrow()
{
await using TestScenario scenario = Scenario();
BlobClient[] good = await scenario.CreateBlobsAsync(2);
Uri[] bad = scenario.GetInvalidBlobUris(1);
BlobBatchClient client = scenario.GetBlobBatchClient();
using BlobBatch batch = client.CreateBatch();
Response response1 = batch.DeleteBlob(good[0].Uri);
Response response2 = batch.DeleteBlob(good[1].Uri);
Response response3 = batch.DeleteBlob(bad[0]);
Response response = await client.SubmitBatchAsync(batch, throwOnAnyFailure : false);
Assert.AreEqual(3, batch.RequestCount);
scenario.AssertStatus(202, response, response1, response2);
scenario.AssertStatus(404, response3);
await scenario.AssertDeleted(good);
}
public async Task SetBlobAccessTier_OneFails_Convenience()
{
await using TestScenario scenario = Scenario();
BlobClient[] good = await scenario.CreateBlobsAsync(2);
Uri[] bad = scenario.GetInvalidBlobUris(1);
Uri[] uris = good.Select(b => b.Uri).Concat(bad).ToArray();
BlobBatchClient client = scenario.GetBlobBatchClient();
AggregateException exes = Assert.ThrowsAsync <AggregateException>(
async() => await client.SetBlobsAccessTierAsync(uris, AccessTier.Cool));
RequestFailedException ex = exes.InnerException as RequestFailedException;
Assert.IsNotNull(ex);
Assert.AreEqual(404, ex.Status);
Assert.IsTrue(BlobErrorCode.ContainerNotFound == ex.ErrorCode);
await scenario.AssertTiers(AccessTier.Cool, good);
}
public async Task Delete_Basic()
{
await using TestScenario scenario = Scenario();
BlobClient[] blobs = await scenario.CreateBlobsAsync(3);
BlobBatchClient client = scenario.GetBlobBatchClient();
using BlobBatch batch = client.CreateBatch();
Response[] responses = new Response[]
{
batch.DeleteBlob(blobs[0].Uri),
batch.DeleteBlob(blobs[1].Uri),
batch.DeleteBlob(blobs[2].Uri)
};
Response response = await client.SubmitBatchAsync(batch);
scenario.AssertStatus(202, response);
scenario.AssertStatus(202, responses);
await scenario.AssertDeleted(blobs);
}
public async Task Delete_MultipleFail()
{
await using TestScenario scenario = Scenario();
BlobClient[] good = await scenario.CreateBlobsAsync(1);
Uri[] bad = scenario.GetInvalidBlobUris(2);
BlobBatchClient client = scenario.GetBlobBatchClient();
using BlobBatch batch = client.CreateBatch();
Response response1 = batch.DeleteBlob(good[0].Uri);
Response response2 = batch.DeleteBlob(bad[0]);
Response response3 = batch.DeleteBlob(bad[1]);
AggregateException exes = Assert.ThrowsAsync <AggregateException>(
async() => await client.SubmitBatchAsync(batch, throwOnAnyFailure: true));
Assert.AreEqual(2, exes.InnerExceptions.Count);
Assert.AreEqual(404, (exes.InnerExceptions[0] as RequestFailedException)?.Status);
Assert.AreEqual(404, (exes.InnerExceptions[1] as RequestFailedException)?.Status);
await scenario.AssertDeleted(good);
}
public async Task Batch_Dispose_Response_Still_Available()
{
await using TestScenario scenario = Scenario();
BlobClient[] blobs = await scenario.CreateBlobsAsync(3);
BlobBatchClient client = scenario.GetBlobBatchClient();
Response[] responses = new Response[3];
Response response;
using (BlobBatch batch = client.CreateBatch())
{
responses[0] = batch.DeleteBlob(blobs[0].Uri);
responses[1] = batch.DeleteBlob(blobs[1].Uri);
responses[2] = batch.DeleteBlob(blobs[2].Uri);
response = await client.SubmitBatchAsync(batch);
}
scenario.AssertStatus(202, response);
scenario.AssertStatus(202, responses);
await scenario.AssertDeleted(blobs);
}
public async Task SetBlobAccessTier_Version()
{
await using TestScenario scenario = Scenario();
BlockBlobClient[] blobs = await scenario.CreateBlockBlobsAsync(1);
Response <BlobInfo> setMetadataResponse = await blobs[0].SetMetadataAsync(BuildMetadata());
blobs[0] = blobs[0].WithVersion(setMetadataResponse.Value.VersionId);
BlobBatchClient client = scenario.GetBlobBatchClient();
using BlobBatch batch = client.CreateBatch();
Response[] responses = new Response[]
{
batch.SetBlobAccessTier(blobs[0].Uri, AccessTier.Cool),
};
Response response = await client.SubmitBatchAsync(batch);
scenario.AssertStatus(202, response);
scenario.AssertStatus(200, responses);
await scenario.AssertTiers(AccessTier.Cool, blobs);
}
public async Task SetBlobAccessTier_Snapshot()
{
await using TestScenario scenario = Scenario();
BlockBlobClient[] blobs = await scenario.CreateBlockBlobsAsync(1);
Response <BlobSnapshotInfo> blobSnapshotResponse = await blobs[0].CreateSnapshotAsync();
blobs[0] = blobs[0].WithSnapshot(blobSnapshotResponse.Value.Snapshot);
BlobBatchClient client = scenario.GetBlobBatchClient();
using BlobBatch batch = client.CreateBatch();
Response[] responses = new Response[]
{
batch.SetBlobAccessTier(blobs[0].Uri, AccessTier.Cool),
};
Response response = await client.SubmitBatchAsync(batch);
scenario.AssertStatus(202, response);
scenario.AssertStatus(200, responses);
await scenario.AssertTiers(AccessTier.Cool, blobs);
}
public async Task SetBlobAccessTier_OneFails()
{
using TestScenario scenario = Scenario();
BlobClient[] good = await scenario.CreateBlobsAsync(2);
Uri[] bad = scenario.GetInvalidBlobUris(1);
BlobBatchClient client = scenario.GetBlobBatchClient();
BlobBatch batch = client.CreateBatch();
Response response1 = batch.SetBlobAccessTier(good[0].Uri, AccessTier.Cool);
Response response2 = batch.SetBlobAccessTier(good[1].Uri, AccessTier.Cool);
Response response3 = batch.SetBlobAccessTier(bad[0], AccessTier.Cool);
AggregateException exes = Assert.ThrowsAsync <AggregateException>(
async() => await client.SubmitBatchAsync(batch));
RequestFailedException ex = exes.InnerException as RequestFailedException;
Assert.IsNotNull(ex);
Assert.AreEqual(404, ex.Status);
Assert.IsTrue(BlobErrorCode.ContainerNotFound == ex.ErrorCode);
await scenario.AssertTiers(AccessTier.Cool, good);
}
public async Task Delete_OneFails()
{
await using TestScenario scenario = Scenario();
BlobClient[] good = await scenario.CreateBlobsAsync(2);
Uri[] bad = scenario.GetInvalidBlobUris(1);
BlobBatchClient client = scenario.GetBlobBatchClient();
using BlobBatch batch = client.CreateBatch();
Response response1 = batch.DeleteBlob(good[0].Uri);
Response response2 = batch.DeleteBlob(good[1].Uri);
Response response3 = batch.DeleteBlob(bad[0]);
AggregateException exes = Assert.ThrowsAsync <AggregateException>(
async() => await client.SubmitBatchAsync(batch, throwOnAnyFailure: true));
RequestFailedException ex = exes.InnerException as RequestFailedException;
Assert.IsNotNull(ex);
Assert.AreEqual(404, ex.Status);
Assert.IsTrue(BlobErrorCode.ContainerNotFound == ex.ErrorCode);
await scenario.AssertDeleted(good);
}
