public async Task CloudPageBlobResizeAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); CloudPageBlob blob2 = container.GetPageBlobReference("blob1"); await blob.CreateAsync(1024); Assert.AreEqual(1024, blob.Properties.Length); await blob2.FetchAttributesAsync(); Assert.AreEqual(1024, blob2.Properties.Length); await blob.ResizeAsync(2048); Assert.AreEqual(2048, blob.Properties.Length); await blob2.FetchAttributesAsync(); Assert.AreEqual(2048, blob2.Properties.Length); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudPageBlobSetMetadataAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.CreateAsync(1024); CloudPageBlob blob2 = container.GetPageBlobReference("blob1"); await blob2.FetchAttributesAsync(); Assert.AreEqual(0, blob2.Metadata.Count); OperationContext operationContext = new OperationContext(); blob.Metadata["key1"] = null; Assert.ThrowsException <AggregateException>( () => blob.SetMetadataAsync(null, null, operationContext).AsTask().Wait(), "Metadata keys should have a non-null value"); Assert.IsInstanceOfType(operationContext.LastResult.Exception.InnerException, typeof(ArgumentException)); blob.Metadata["key1"] = ""; Assert.ThrowsException <AggregateException>( () => blob.SetMetadataAsync(null, null, operationContext).AsTask().Wait(), "Metadata keys should have a non-empty value"); Assert.IsInstanceOfType(operationContext.LastResult.Exception.InnerException, typeof(ArgumentException)); blob.Metadata["key1"] = "value1"; await blob.SetMetadataAsync(); await blob2.FetchAttributesAsync(); Assert.AreEqual(1, blob2.Metadata.Count); Assert.AreEqual("value1", blob2.Metadata["key1"]); BlobResultSegment results = await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.Metadata, null, null, null, null); CloudPageBlob blob3 = (CloudPageBlob)results.Results.First(); Assert.AreEqual(1, blob3.Metadata.Count); Assert.AreEqual("value1", blob3.Metadata["key1"]); blob.Metadata.Clear(); await blob.SetMetadataAsync(); await blob2.FetchAttributesAsync(); Assert.AreEqual(0, blob2.Metadata.Count); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
private static async Task TestAccessAsync(BlobContainerPublicAccessType accessType, CloudBlobContainer container, CloudBlob inputBlob) { StorageCredentials credentials = new StorageCredentials(); container = new CloudBlobContainer(container.Uri, credentials); CloudPageBlob blob = new CloudPageBlob(inputBlob.Uri, credentials); OperationContext context = new OperationContext(); BlobRequestOptions options = new BlobRequestOptions(); if (accessType.Equals(BlobContainerPublicAccessType.Container)) { await blob.FetchAttributesAsync(); await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, options, context); await container.FetchAttributesAsync(); } else if (accessType.Equals(BlobContainerPublicAccessType.Blob)) { await blob.FetchAttributesAsync(); await TestHelper.ExpectedExceptionAsync( async() => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, options, context), context, "List blobs while public access does not allow for listing", HttpStatusCode.NotFound); await TestHelper.ExpectedExceptionAsync( async() => await container.FetchAttributesAsync(null, options, context), context, "Fetch container attributes while public access does not allow", HttpStatusCode.NotFound); } else { await TestHelper.ExpectedExceptionAsync( async() => await blob.FetchAttributesAsync(null, options, context), context, "Fetch blob attributes while public access does not allow", HttpStatusCode.NotFound); await TestHelper.ExpectedExceptionAsync( async() => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, options, context), context, "List blobs while public access does not allow for listing", HttpStatusCode.NotFound); await TestHelper.ExpectedExceptionAsync( async() => await container.FetchAttributesAsync(null, options, context), context, "Fetch container attributes while public access does not allow", HttpStatusCode.NotFound); } }
public void CloudPageBlobCopyTestTask() { CloudBlobContainer container = GetRandomContainerReference(); try { container.CreateAsync().Wait(); CloudPageBlob source = container.GetPageBlobReference("source"); string data = new string('a', 512); UploadTextTask(source, data, Encoding.UTF8); source.Metadata["Test"] = "value"; source.SetMetadataAsync().Wait(); CloudPageBlob copy = container.GetPageBlobReference("copy"); string copyId = copy.StartCopyAsync(TestHelper.Defiddler(source)).Result; Assert.AreEqual(BlobType.PageBlob, copy.BlobType); WaitForCopyTask(copy); Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status); Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath); Assert.AreEqual(data.Length, copy.CopyState.TotalBytes); Assert.AreEqual(data.Length, copy.CopyState.BytesCopied); Assert.AreEqual(copyId, copy.CopyState.CopyId); Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); TestHelper.ExpectedExceptionTask( copy.AbortCopyAsync(copyId), "Aborting a copy operation after completion should fail", HttpStatusCode.Conflict, "NoPendingCopyOperation"); source.FetchAttributesAsync().Wait(); Assert.IsNotNull(copy.Properties.ETag); Assert.AreNotEqual(source.Properties.ETag, copy.Properties.ETag); Assert.IsTrue(copy.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); string copyData = DownloadTextTask(copy, Encoding.UTF8); Assert.AreEqual(data, copyData, "Data inside copy of blob not similar"); copy.FetchAttributesAsync().Wait(); BlobProperties prop1 = copy.Properties; BlobProperties prop2 = source.Properties; Assert.AreEqual(prop1.CacheControl, prop2.CacheControl); Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding); Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage); Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5); Assert.AreEqual(prop1.ContentType, prop2.ContentType); Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same"); copy.DeleteAsync().Wait(); } finally { container.DeleteIfExistsAsync().Wait(); } }
private static async Task TestAccessAsync(BlobContainerPublicAccessType accessType, CloudBlobContainer container, CloudBlob inputBlob) { StorageCredentials credentials = new StorageCredentials(); container = new CloudBlobContainer(container.Uri, credentials); CloudPageBlob blob = new CloudPageBlob(inputBlob.Uri, credentials); OperationContext context = new OperationContext(); BlobRequestOptions options = new BlobRequestOptions(); if (accessType.Equals(BlobContainerPublicAccessType.Container)) { await blob.FetchAttributesAsync(); await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, options, context); await container.FetchAttributesAsync(); } else if (accessType.Equals(BlobContainerPublicAccessType.Blob)) { await blob.FetchAttributesAsync(); await TestHelper.ExpectedExceptionAsync( async () => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, options, context), context, "List blobs while public access does not allow for listing", HttpStatusCode.NotFound); await TestHelper.ExpectedExceptionAsync( async () => await container.FetchAttributesAsync(null, options, context), context, "Fetch container attributes while public access does not allow", HttpStatusCode.NotFound); } else { await TestHelper.ExpectedExceptionAsync( async () => await blob.FetchAttributesAsync(null, options, context), context, "Fetch blob attributes while public access does not allow", HttpStatusCode.NotFound); await TestHelper.ExpectedExceptionAsync( async () => await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, options, context), context, "List blobs while public access does not allow for listing", HttpStatusCode.NotFound); await TestHelper.ExpectedExceptionAsync( async () => await container.FetchAttributesAsync(null, options, context), context, "Fetch container attributes while public access does not allow", HttpStatusCode.NotFound); } }
public async Task BlobWriteStreamOpenAndCloseAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); // Block blob tests CloudBlockBlob blockBlob = container.GetBlockBlobReference("blob1"); using (Stream writeStream = await blockBlob.OpenWriteAsync()) { } CloudBlockBlob blockBlob2 = container.GetBlockBlobReference(blockBlob.Name); await blockBlob2.FetchAttributesAsync(); Assert.AreEqual(0, blockBlob2.Properties.Length); Assert.AreEqual(BlobType.BlockBlob, blockBlob2.Properties.BlobType); // Page blob tests CloudPageBlob pageBlob = container.GetPageBlobReference("blob2"); OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await pageBlob.OpenWriteAsync(null, null, null, opContext), opContext, "Opening a page blob stream with no size should fail on a blob that does not exist", HttpStatusCode.NotFound); using (Stream writeStream = await pageBlob.OpenWriteAsync(1024)) { } using (Stream writeStream = await pageBlob.OpenWriteAsync(null)) { } CloudPageBlob pageBlob2 = container.GetPageBlobReference(pageBlob.Name); await pageBlob2.FetchAttributesAsync(); Assert.AreEqual(1024, pageBlob2.Properties.Length); Assert.AreEqual(BlobType.PageBlob, pageBlob2.Properties.BlobType); // Append blob test CloudAppendBlob appendBlob = container.GetAppendBlobReference("blob3"); using (Stream writeStream = await appendBlob.OpenWriteAsync(true)) { } CloudAppendBlob appendBlob2 = container.GetAppendBlobReference(appendBlob.Name); await appendBlob2.FetchAttributesAsync(); Assert.AreEqual(0, appendBlob2.Properties.Length); Assert.AreEqual(BlobType.AppendBlob, appendBlob2.Properties.BlobType); } finally { container.DeleteAsync().Wait(); } }
public async Task CloudPageBlobCopyTestWithMetadataOverrideAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob source = container.GetPageBlobReference("source"); string data = new string('a', 512); await UploadTextAsync(source, data, Encoding.UTF8); source.Metadata["Test"] = "value"; await source.SetMetadataAsync(); CloudPageBlob copy = container.GetPageBlobReference("copy"); copy.Metadata["Test2"] = "value2"; string copyId = await copy.StartCopyFromBlobAsync(TestHelper.Defiddler(source)); await WaitForCopyAsync(copy); Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status); Assert.AreEqual(source.Uri.AbsolutePath, copy.CopyState.Source.AbsolutePath); Assert.AreEqual(data.Length, copy.CopyState.TotalBytes); Assert.AreEqual(data.Length, copy.CopyState.BytesCopied); Assert.AreEqual(copyId, copy.CopyState.CopyId); Assert.IsTrue(copy.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); string copyData = await DownloadTextAsync(copy, Encoding.UTF8); Assert.AreEqual(data, copyData, "Data inside copy of blob not similar"); await copy.FetchAttributesAsync(); await source.FetchAttributesAsync(); BlobProperties prop1 = copy.Properties; BlobProperties prop2 = source.Properties; Assert.AreEqual(prop1.CacheControl, prop2.CacheControl); Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition); Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding); Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage); Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5); Assert.AreEqual(prop1.ContentType, prop2.ContentType); Assert.AreEqual("value2", copy.Metadata["Test2"], false, "Copied metadata not same"); Assert.IsFalse(copy.Metadata.ContainsKey("Test"), "Source Metadata should not appear in destination blob"); await copy.DeleteAsync(); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudPageBlobSetPropertiesAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.CreateAsync(1024); string eTag = blob.Properties.ETag; DateTimeOffset lastModified = blob.Properties.LastModified.Value; await Task.Delay(1000); blob.Properties.CacheControl = "no-transform"; blob.Properties.ContentEncoding = "gzip"; blob.Properties.ContentLanguage = "tr,en"; blob.Properties.ContentMD5 = "MDAwMDAwMDA="; blob.Properties.ContentType = "text/html"; await blob.SetPropertiesAsync(); Assert.IsTrue(blob.Properties.LastModified > lastModified); Assert.AreNotEqual(eTag, blob.Properties.ETag); CloudPageBlob blob2 = container.GetPageBlobReference("blob1"); await blob2.FetchAttributesAsync(); Assert.AreEqual("no-transform", blob2.Properties.CacheControl); Assert.AreEqual("gzip", blob2.Properties.ContentEncoding); Assert.AreEqual("tr,en", blob2.Properties.ContentLanguage); Assert.AreEqual("MDAwMDAwMDA=", blob2.Properties.ContentMD5); Assert.AreEqual("text/html", blob2.Properties.ContentType); CloudPageBlob blob3 = container.GetPageBlobReference("blob1"); using (MemoryStream stream = new MemoryStream()) { BlobRequestOptions options = new BlobRequestOptions() { DisableContentMD5Validation = true, }; await blob3.DownloadToStreamAsync(stream.AsOutputStream(), null, options, null); } AssertAreEqual(blob2.Properties, blob3.Properties); BlobResultSegment results = await container.ListBlobsSegmentedAsync(null); CloudPageBlob blob4 = (CloudPageBlob)results.Results.First(); AssertAreEqual(blob2.Properties, blob4.Properties); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task PageBlobWriteStreamRandomSeekTestAsync() { byte[] buffer = GetRandomBuffer(3 * 1024 * 1024); CloudBlobContainer container = GetRandomContainerReference(); container.ServiceClient.ParallelOperationThreadCount = 2; try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); using (MemoryStream wholeBlob = new MemoryStream()) { using (IOutputStream writeStream = await blob.OpenWriteAsync(buffer.Length)) { Stream blobStream = writeStream.AsStreamForWrite(); TestHelper.ExpectedException <ArgumentOutOfRangeException>( () => blobStream.Seek(1, SeekOrigin.Begin), "Page blob stream should not allow unaligned seeks"); await blobStream.WriteAsync(buffer, 0, buffer.Length); await wholeBlob.WriteAsync(buffer, 0, buffer.Length); Random random = new Random(); for (int i = 0; i < 10; i++) { int offset = random.Next(buffer.Length / 512) * 512; SeekRandomly(blobStream, offset); await blobStream.WriteAsync(buffer, 0, buffer.Length - offset); wholeBlob.Seek(offset, SeekOrigin.Begin); await wholeBlob.WriteAsync(buffer, 0, buffer.Length - offset); } } wholeBlob.Seek(0, SeekOrigin.End); await blob.FetchAttributesAsync(); Assert.IsNull(blob.Properties.ContentMD5); using (MemoryStream downloadedBlob = new MemoryStream()) { await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream()); TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob); } } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task PageBlobWriteStreamBasicTestAsync() { byte[] buffer = GetRandomBuffer(3 * 1024 * 1024); CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); CloudBlobClient blobClient = GenerateCloudBlobClient(); blobClient.ParallelOperationThreadCount = 2; string name = GetRandomContainerName(); CloudBlobContainer container = blobClient.GetContainerReference(name); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); using (MemoryStream wholeBlob = new MemoryStream()) { BlobRequestOptions options = new BlobRequestOptions() { StoreBlobContentMD5 = true, }; using (IOutputStream writeStream = await blob.OpenWriteAsync(buffer.Length * 3, null, options, null)) { Stream blobStream = writeStream.AsStreamForWrite(); for (int i = 0; i < 3; i++) { await blobStream.WriteAsync(buffer, 0, buffer.Length); await wholeBlob.WriteAsync(buffer, 0, buffer.Length); Assert.AreEqual(wholeBlob.Position, blobStream.Position); hasher.Append(buffer.AsBuffer()); } } string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryStream downloadedBlob = new MemoryStream()) { await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream()); TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob); } } } finally { container.DeleteAsync().AsTask().Wait(); } }
public async Task CloudPageBlobSnapshotAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.CreateAsync(1024); CloudPageBlob snapshot1 = await blob.CreateSnapshotAsync(); Assert.AreEqual(blob.Properties.ETag, snapshot1.Properties.ETag); Assert.AreEqual(blob.Properties.LastModified, snapshot1.Properties.LastModified); Assert.IsNotNull(snapshot1.SnapshotTime, "Snapshot does not have SnapshotTime set"); CloudPageBlob snapshot2 = await blob.CreateSnapshotAsync(); Assert.IsTrue(snapshot2.SnapshotTime.Value > snapshot1.SnapshotTime.Value); await snapshot1.FetchAttributesAsync(); await snapshot2.FetchAttributesAsync(); await blob.FetchAttributesAsync(); AssertAreEqual(snapshot1.Properties, blob.Properties); CloudPageBlob snapshotCopy = container.GetPageBlobReference("blob2"); await snapshotCopy.StartCopyFromBlobAsync(TestHelper.Defiddler(snapshot1.Uri)); await WaitForCopyAsync(snapshotCopy); Assert.AreEqual(CopyStatus.Success, snapshotCopy.CopyState.Status); await TestHelper.ExpectedExceptionAsync <InvalidOperationException>( async() => await snapshot1.OpenWriteAsync(1024), "Trying to write to a blob snapshot should fail"); BlobResultSegment resultSegment = await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, null, null); List <IListBlobItem> blobs = resultSegment.Results.ToList(); Assert.AreEqual(4, blobs.Count); AssertAreEqual(snapshot1, (ICloudBlob)blobs[0]); AssertAreEqual(snapshot2, (ICloudBlob)blobs[1]); AssertAreEqual(blob, (ICloudBlob)blobs[2]); AssertAreEqual(snapshotCopy, (ICloudBlob)blobs[3]); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
private static void TestAccessTask(BlobContainerPublicAccessType accessType, CloudBlobContainer container, ICloudBlob inputBlob) { StorageCredentials credentials = new StorageCredentials(); container = new CloudBlobContainer(container.Uri, credentials); CloudPageBlob blob = new CloudPageBlob(inputBlob.Uri, credentials); if (accessType.Equals(BlobContainerPublicAccessType.Container)) { blob.FetchAttributesAsync().Wait(); BlobContinuationToken token = null; do { BlobResultSegment results = container.ListBlobsSegmented(token); results.Results.ToArray(); token = results.ContinuationToken; } while (token != null); container.FetchAttributesAsync().Wait(); } else if (accessType.Equals(BlobContainerPublicAccessType.Blob)) { blob.FetchAttributesAsync().Wait(); TestHelper.ExpectedExceptionTask( container.ListBlobsSegmentedAsync(null), "List blobs while public access does not allow for listing", HttpStatusCode.NotFound); TestHelper.ExpectedExceptionTask( container.FetchAttributesAsync(), "Fetch container attributes while public access does not allow", HttpStatusCode.NotFound); } else { TestHelper.ExpectedExceptionTask( blob.FetchAttributesAsync(), "Fetch blob attributes while public access does not allow", HttpStatusCode.NotFound); TestHelper.ExpectedExceptionTask( container.ListBlobsSegmentedAsync(null), "List blobs while public access does not allow for listing", HttpStatusCode.NotFound); TestHelper.ExpectedExceptionTask( container.FetchAttributesAsync(), "Fetch container attributes while public access does not allow", HttpStatusCode.NotFound); } }
private async Task CloudPageBlobUploadFromStreamAsync(int startOffset) { byte[] buffer = GetRandomBuffer(1 * 1024 * 1024); CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); hasher.Append(buffer.AsBuffer(startOffset, buffer.Length - startOffset)); string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); using (MemoryStream originalBlob = new MemoryStream()) { originalBlob.Write(buffer, startOffset, buffer.Length - startOffset); using (MemoryStream sourceStream = new MemoryStream(buffer)) { sourceStream.Seek(startOffset, SeekOrigin.Begin); BlobRequestOptions options = new BlobRequestOptions() { StoreBlobContentMD5 = true, }; await blob.UploadFromStreamAsync(sourceStream.AsInputStream(), null, options, null); } await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryStream downloadedBlob = new MemoryStream()) { await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream()); TestHelper.AssertStreamsAreEqual(originalBlob, downloadedBlob); } } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task BlobUploadWithoutMD5ValidationAndStoreBlobContentTestAsync() { byte[] buffer = GetRandomBuffer(2 * 1024); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); BlobRequestOptions options = new BlobRequestOptions(); options.DisableContentMD5Validation = false; options.StoreBlobContentMD5 = false; OperationContext context = new OperationContext(); using (MemoryStream srcStream = new MemoryStream(buffer)) { await blob.UploadFromStreamAsync(srcStream.AsInputStream(), null, options, context); await blob.FetchAttributesAsync(); string md5 = blob.Properties.ContentMD5; blob.Properties.ContentMD5 = "MDAwMDAwMDA="; await blob.SetPropertiesAsync(null, options, context); byte[] testBuffer = new byte[2048]; MemoryStream dstStream = new MemoryStream(testBuffer); await TestHelper.ExpectedExceptionAsync(async() => await blob.DownloadRangeToStreamAsync(dstStream.AsOutputStream(), null, null, null, options, context), context, "Try to Download a stream with a corrupted md5 and DisableMD5Validation set to false", HttpStatusCode.OK); options.DisableContentMD5Validation = true; await blob.SetPropertiesAsync(null, options, context); byte[] testBuffer2 = new byte[2048]; MemoryStream dstStream2 = new MemoryStream(testBuffer2); await blob.DownloadRangeToStreamAsync(dstStream2.AsOutputStream(), null, null, null, options, context); } } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudPageBlobFetchAttributesAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.CreateAsync(1024); Assert.AreEqual(1024, blob.Properties.Length); Assert.IsNotNull(blob.Properties.ETag); Assert.IsTrue(blob.Properties.LastModified > DateTimeOffset.UtcNow.AddMinutes(-5)); Assert.IsNull(blob.Properties.CacheControl); Assert.IsNull(blob.Properties.ContentEncoding); Assert.IsNull(blob.Properties.ContentLanguage); Assert.IsNull(blob.Properties.ContentType); Assert.IsNull(blob.Properties.ContentMD5); Assert.AreEqual(LeaseStatus.Unspecified, blob.Properties.LeaseStatus); Assert.AreEqual(BlobType.PageBlob, blob.Properties.BlobType); CloudPageBlob blob2 = container.GetPageBlobReference("blob1"); await blob2.FetchAttributesAsync(); Assert.AreEqual(1024, blob2.Properties.Length); Assert.AreEqual(blob.Properties.ETag, blob2.Properties.ETag); Assert.AreEqual(blob.Properties.LastModified, blob2.Properties.LastModified); Assert.IsNull(blob2.Properties.CacheControl); Assert.IsNull(blob2.Properties.ContentEncoding); Assert.IsNull(blob2.Properties.ContentLanguage); Assert.AreEqual("application/octet-stream", blob2.Properties.ContentType); Assert.IsNull(blob2.Properties.ContentMD5); Assert.AreEqual(LeaseStatus.Unlocked, blob2.Properties.LeaseStatus); Assert.AreEqual(BlobType.PageBlob, blob2.Properties.BlobType); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudPageBlobSnapshotMetadataAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.CreateAsync(1024); blob.Metadata["Hello"] = "World"; blob.Metadata["Marco"] = "Polo"; await blob.SetMetadataAsync(); IDictionary <string, string> snapshotMetadata = new Dictionary <string, string>(); snapshotMetadata["Hello"] = "Dolly"; snapshotMetadata["Yoyo"] = "Ma"; CloudPageBlob snapshot = await blob.CreateSnapshotAsync(snapshotMetadata, null, null, null); // Test the client view against the expected metadata // None of the original metadata should be present Assert.AreEqual("Dolly", snapshot.Metadata["Hello"]); Assert.AreEqual("Ma", snapshot.Metadata["Yoyo"]); Assert.IsFalse(snapshot.Metadata.ContainsKey("Marco")); // Test the server view against the expected metadata await snapshot.FetchAttributesAsync(); Assert.AreEqual("Dolly", snapshot.Metadata["Hello"]); Assert.AreEqual("Ma", snapshot.Metadata["Yoyo"]); Assert.IsFalse(snapshot.Metadata.ContainsKey("Marco")); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
private async Task CloudPageBlobUploadFromStreamAsync(CloudBlobContainer container, int size, AccessCondition accessCondition, OperationContext operationContext, int startOffset) { byte[] buffer = GetRandomBuffer(size); CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); hasher.Append(buffer.AsBuffer(startOffset, buffer.Length - startOffset)); string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = 512; using (MemoryStream originalBlob = new MemoryStream()) { originalBlob.Write(buffer, startOffset, buffer.Length - startOffset); using (MemoryStream sourceStream = new MemoryStream(buffer)) { sourceStream.Seek(startOffset, SeekOrigin.Begin); BlobRequestOptions options = new BlobRequestOptions() { StoreBlobContentMD5 = true, }; await blob.UploadFromStreamAsync(sourceStream.AsInputStream(), accessCondition, options, operationContext); } await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryStream downloadedBlob = new MemoryStream()) { await blob.DownloadToStreamAsync(downloadedBlob.AsOutputStream()); TestHelper.AssertStreamsAreEqual(originalBlob, downloadedBlob); } } }
public async Task CloudPageBlobCreateWithMetadataAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.Metadata["key1"] = "value1"; await blob.CreateAsync(1024); CloudPageBlob blob2 = container.GetPageBlobReference("blob1"); await blob2.FetchAttributesAsync(); Assert.AreEqual(1, blob2.Metadata.Count); Assert.AreEqual("value1", blob2.Metadata["key1"]); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudBlockBlobFetchAttributesInvalidTypeAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudBlockBlob blob = container.GetBlockBlobReference("blob1"); await CreateForTestAsync(blob, 1, 1024); CloudPageBlob blob2 = container.GetPageBlobReference("blob1"); OperationContext operationContext = new OperationContext(); Assert.ThrowsException <AggregateException>( () => blob2.FetchAttributesAsync(null, null, operationContext).AsTask().Wait(), "Fetching attributes of a block blob using a page blob reference should fail"); Assert.IsInstanceOfType(operationContext.LastResult.Exception.InnerException, typeof(InvalidOperationException)); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudPageBlobSnapshotAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024)); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.UploadFromStreamAsync(originalData); Assert.IsFalse(blob.IsSnapshot); Assert.IsNull(blob.SnapshotTime, "Root blob has SnapshotTime set"); Assert.IsFalse(blob.SnapshotQualifiedUri.Query.Contains("snapshot")); Assert.AreEqual(blob.Uri, blob.SnapshotQualifiedUri); CloudPageBlob snapshot1 = await blob.CreateSnapshotAsync(); Assert.AreEqual(blob.Properties.ETag, snapshot1.Properties.ETag); Assert.AreEqual(blob.Properties.LastModified, snapshot1.Properties.LastModified); Assert.IsTrue(snapshot1.IsSnapshot); Assert.IsNotNull(snapshot1.SnapshotTime, "Snapshot does not have SnapshotTime set"); Assert.AreEqual(blob.Uri, snapshot1.Uri); Assert.AreNotEqual(blob.SnapshotQualifiedUri, snapshot1.SnapshotQualifiedUri); Assert.AreNotEqual(snapshot1.Uri, snapshot1.SnapshotQualifiedUri); Assert.IsTrue(snapshot1.SnapshotQualifiedUri.Query.Contains("snapshot")); CloudPageBlob snapshot2 = await blob.CreateSnapshotAsync(); Assert.IsTrue(snapshot2.SnapshotTime.Value > snapshot1.SnapshotTime.Value); await snapshot1.FetchAttributesAsync(); await snapshot2.FetchAttributesAsync(); await blob.FetchAttributesAsync(); AssertAreEqual(snapshot1.Properties, blob.Properties); CloudPageBlob snapshot1Clone = new CloudPageBlob(new Uri(blob.Uri + "?snapshot=" + snapshot1.SnapshotTime.Value.ToString("O")), blob.ServiceClient.Credentials); Assert.IsNotNull(snapshot1Clone.SnapshotTime, "Snapshot clone does not have SnapshotTime set"); Assert.AreEqual(snapshot1.SnapshotTime.Value, snapshot1Clone.SnapshotTime.Value); await snapshot1Clone.FetchAttributesAsync(); AssertAreEqual(snapshot1.Properties, snapshot1Clone.Properties); CloudPageBlob snapshotCopy = container.GetPageBlobReference("blob2"); await snapshotCopy.StartCopyAsync(TestHelper.Defiddler(snapshot1.Uri)); await WaitForCopyAsync(snapshotCopy); Assert.AreEqual(CopyStatus.Success, snapshotCopy.CopyState.Status); await TestHelper.ExpectedExceptionAsync<InvalidOperationException>( async () => await snapshot1.OpenWriteAsync(1024), "Trying to write to a blob snapshot should fail"); using (Stream snapshotStream = (await snapshot1.OpenReadAsync())) { snapshotStream.Seek(0, SeekOrigin.End); TestHelper.AssertStreamsAreEqual(originalData, snapshotStream); } await blob.CreateAsync(1024); using (Stream snapshotStream = (await snapshot1.OpenReadAsync())) { snapshotStream.Seek(0, SeekOrigin.End); TestHelper.AssertStreamsAreEqual(originalData, snapshotStream); } BlobResultSegment resultSegment = await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, null, null); List<IListBlobItem> blobs = resultSegment.Results.ToList(); Assert.AreEqual(4, blobs.Count); AssertAreEqual(snapshot1, (CloudBlob)blobs[0]); AssertAreEqual(snapshot2, (CloudBlob)blobs[1]); AssertAreEqual(blob, (CloudBlob)blobs[2]); AssertAreEqual(snapshotCopy, (CloudBlob)blobs[3]); } finally { container.DeleteIfExistsAsync().Wait(); } }
public async Task PageBlobWriteStreamBasicTestAsync() { byte[] buffer = GetRandomBuffer(6 * 512); CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); CloudBlobContainer container = GetRandomContainerReference(); container.ServiceClient.DefaultRequestOptions.ParallelOperationThreadCount = 2; try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); blob.StreamWriteSizeInBytes = 8 * 512; using (MemoryStream wholeBlob = new MemoryStream()) { BlobRequestOptions options = new BlobRequestOptions() { StoreBlobContentMD5 = true, }; using (IOutputStream writeStream = await blob.OpenWriteAsync(buffer.Length * 3, null, options, null)) { Stream blobStream = writeStream.AsStreamForWrite(); for (int i = 0; i < 3; i++) { await blobStream.WriteAsync(buffer, 0, buffer.Length); await wholeBlob.WriteAsync(buffer, 0, buffer.Length); Assert.AreEqual(wholeBlob.Position, blobStream.Position); hasher.Append(buffer.AsBuffer()); } await blobStream.FlushAsync(); } string md5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryOutputStream downloadedBlob = new MemoryOutputStream()) { await blob.DownloadToStreamAsync(downloadedBlob); TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob.UnderlyingStream); } await TestHelper.ExpectedExceptionAsync <ArgumentException>( async() => await blob.OpenWriteAsync(null, null, options, null), "OpenWrite with StoreBlobContentMD5 on an existing page blob should fail"); using (IOutputStream writeStream = await blob.OpenWriteAsync(null)) { Stream blobStream = writeStream.AsStreamForWrite(); blobStream.Seek(buffer.Length / 2, SeekOrigin.Begin); wholeBlob.Seek(buffer.Length / 2, SeekOrigin.Begin); for (int i = 0; i < 2; i++) { blobStream.Write(buffer, 0, buffer.Length); wholeBlob.Write(buffer, 0, buffer.Length); Assert.AreEqual(wholeBlob.Position, blobStream.Position); } await blobStream.FlushAsync(); } await blob.FetchAttributesAsync(); Assert.AreEqual(md5, blob.Properties.ContentMD5); using (MemoryOutputStream downloadedBlob = new MemoryOutputStream()) { options.DisableContentMD5Validation = true; await blob.DownloadToStreamAsync(downloadedBlob, null, options, null); TestHelper.AssertStreamsAreEqual(wholeBlob, downloadedBlob.UnderlyingStream); } } } finally { container.DeleteAsync().AsTask().Wait(); } }
public async Task CloudPageBlobConditionalAccessAsync() { OperationContext operationContext = new OperationContext(); CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.CreateAsync(1024); await blob.FetchAttributesAsync(); string currentETag = blob.Properties.ETag; DateTimeOffset currentModifiedTime = blob.Properties.LastModified.Value; // ETag conditional tests blob.Metadata["ETagConditionalName"] = "ETagConditionalValue"; await blob.SetMetadataAsync(AccessCondition.GenerateIfMatchCondition(currentETag), null, null); await blob.FetchAttributesAsync(); string newETag = blob.Properties.ETag; Assert.AreNotEqual(newETag, currentETag, "ETage should be modified on write metadata"); blob.Metadata["ETagConditionalName"] = "ETagConditionalValue2"; await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNoneMatchCondition(newETag), null, operationContext), operationContext, "If none match on conditional test should throw", HttpStatusCode.PreconditionFailed, "ConditionNotMet"); string invalidETag = "\"0x10101010\""; await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfMatchCondition(invalidETag), null, operationContext), operationContext, "Invalid ETag on conditional test should throw", HttpStatusCode.PreconditionFailed, "ConditionNotMet"); currentETag = blob.Properties.ETag; await blob.SetMetadataAsync(AccessCondition.GenerateIfNoneMatchCondition(invalidETag), null, null); await blob.FetchAttributesAsync(); newETag = blob.Properties.ETag; // LastModifiedTime tests currentModifiedTime = blob.Properties.LastModified.Value; blob.Metadata["DateConditionalName"] = "DateConditionalValue"; await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(currentModifiedTime), null, operationContext), operationContext, "IfModifiedSince conditional on current modified time should throw", HttpStatusCode.PreconditionFailed, "ConditionNotMet"); DateTimeOffset pastTime = currentModifiedTime.Subtract(TimeSpan.FromMinutes(5)); await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(pastTime), null, null); pastTime = currentModifiedTime.Subtract(TimeSpan.FromHours(5)); await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(pastTime), null, null); pastTime = currentModifiedTime.Subtract(TimeSpan.FromDays(5)); await blob.SetMetadataAsync(AccessCondition.GenerateIfModifiedSinceCondition(pastTime), null, null); currentModifiedTime = blob.Properties.LastModified.Value; pastTime = currentModifiedTime.Subtract(TimeSpan.FromMinutes(5)); await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(pastTime), null, operationContext), operationContext, "IfNotModifiedSince conditional on past time should throw", HttpStatusCode.PreconditionFailed, "ConditionNotMet"); pastTime = currentModifiedTime.Subtract(TimeSpan.FromHours(5)); await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(pastTime), null, operationContext), operationContext, "IfNotModifiedSince conditional on past time should throw", HttpStatusCode.PreconditionFailed, "ConditionNotMet"); pastTime = currentModifiedTime.Subtract(TimeSpan.FromDays(5)); await TestHelper.ExpectedExceptionAsync( async() => await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(pastTime), null, operationContext), operationContext, "IfNotModifiedSince conditional on past time should throw", HttpStatusCode.PreconditionFailed, "ConditionNotMet"); blob.Metadata["DateConditionalName"] = "DateConditionalValue2"; currentETag = blob.Properties.ETag; await blob.SetMetadataAsync(AccessCondition.GenerateIfNotModifiedSinceCondition(currentModifiedTime), null, null); await blob.FetchAttributesAsync(); newETag = blob.Properties.ETag; Assert.AreNotEqual(newETag, currentETag, "ETage should be modified on write metadata"); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task StoreBlobContentMD5TestAsync() { BlobRequestOptions optionsWithNoMD5 = new BlobRequestOptions() { StoreBlobContentMD5 = false, }; BlobRequestOptions optionsWithMD5 = new BlobRequestOptions() { StoreBlobContentMD5 = true, }; CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudBlockBlob blob1 = container.GetBlockBlobReference("blob1"); using (Stream stream = new NonSeekableMemoryStream()) { await blob1.UploadFromStreamAsync(stream, null, optionsWithMD5, null); } await blob1.FetchAttributesAsync(); Assert.IsNotNull(blob1.Properties.ContentMD5); blob1 = container.GetBlockBlobReference("blob2"); using (Stream stream = new NonSeekableMemoryStream()) { await blob1.UploadFromStreamAsync(stream, null, optionsWithNoMD5, null); } await blob1.FetchAttributesAsync(); Assert.IsNull(blob1.Properties.ContentMD5); blob1 = container.GetBlockBlobReference("blob3"); using (Stream stream = new NonSeekableMemoryStream()) { await blob1.UploadFromStreamAsync(stream); } await blob1.FetchAttributesAsync(); Assert.IsNotNull(blob1.Properties.ContentMD5); CloudPageBlob blob2 = container.GetPageBlobReference("blob4"); blob2 = container.GetPageBlobReference("blob4"); using (Stream stream = new MemoryStream()) { await blob2.UploadFromStreamAsync(stream, null, optionsWithMD5, null); } await blob2.FetchAttributesAsync(); Assert.IsNotNull(blob2.Properties.ContentMD5); blob2 = container.GetPageBlobReference("blob5"); using (Stream stream = new MemoryStream()) { await blob2.UploadFromStreamAsync(stream, null, optionsWithNoMD5, null); } await blob2.FetchAttributesAsync(); Assert.IsNull(blob2.Properties.ContentMD5); blob2 = container.GetPageBlobReference("blob6"); using (Stream stream = new MemoryStream()) { await blob2.UploadFromStreamAsync(stream); } await blob2.FetchAttributesAsync(); Assert.IsNull(blob2.Properties.ContentMD5); } finally { container.DeleteIfExistsAsync().Wait(); } }
public async Task CloudPageBlobCopyFromSnapshotTestAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); CloudPageBlob source = container.GetPageBlobReference("source"); string data = new string('a', 512); await UploadTextAsync(source, data, Encoding.UTF8); source.Metadata["Test"] = "value"; await source.SetMetadataAsync(); CloudPageBlob snapshot = await source.CreateSnapshotAsync(); //Modify source string newData = new string('b', 512); source.Metadata["Test"] = "newvalue"; await source.SetMetadataAsync(); source.Properties.ContentMD5 = null; await UploadTextAsync(source, newData, Encoding.UTF8); Assert.AreEqual(newData, await DownloadTextAsync(source, Encoding.UTF8), "Source is modified correctly"); Assert.AreEqual(data, await DownloadTextAsync(snapshot, Encoding.UTF8), "Modifying source blob should not modify snapshot"); await source.FetchAttributesAsync(); await snapshot.FetchAttributesAsync(); Assert.AreNotEqual(source.Metadata["Test"], snapshot.Metadata["Test"], "Source and snapshot metadata should be independent"); CloudPageBlob copy = container.GetPageBlobReference("copy"); await copy.StartCopyFromBlobAsync(TestHelper.Defiddler(snapshot)); await WaitForCopyAsync(copy); Assert.AreEqual(CopyStatus.Success, copy.CopyState.Status); Assert.AreEqual(data, await DownloadTextAsync(copy, Encoding.UTF8), "Data inside copy of blob not similar"); await copy.FetchAttributesAsync(); BlobProperties prop1 = copy.Properties; BlobProperties prop2 = snapshot.Properties; Assert.AreEqual(prop1.CacheControl, prop2.CacheControl); Assert.AreEqual(prop1.ContentDisposition, prop2.ContentDisposition); Assert.AreEqual(prop1.ContentEncoding, prop2.ContentEncoding); Assert.AreEqual(prop1.ContentLanguage, prop2.ContentLanguage); Assert.AreEqual(prop1.ContentMD5, prop2.ContentMD5); Assert.AreEqual(prop1.ContentType, prop2.ContentType); Assert.AreEqual("value", copy.Metadata["Test"], false, "Copied metadata not same"); await copy.DeleteAsync(); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudPageBlobSnapshotAsync() { CloudBlobContainer container = GetRandomContainerReference(); try { await container.CreateAsync(); MemoryStream originalData = new MemoryStream(GetRandomBuffer(1024)); CloudPageBlob blob = container.GetPageBlobReference("blob1"); await blob.UploadFromStreamAsync(originalData.AsInputStream()); CloudPageBlob snapshot1 = await blob.CreateSnapshotAsync(); Assert.AreEqual(blob.Properties.ETag, snapshot1.Properties.ETag); Assert.AreEqual(blob.Properties.LastModified, snapshot1.Properties.LastModified); Assert.IsNotNull(snapshot1.SnapshotTime, "Snapshot does not have SnapshotTime set"); CloudPageBlob snapshot2 = await blob.CreateSnapshotAsync(); Assert.IsTrue(snapshot2.SnapshotTime.Value > snapshot1.SnapshotTime.Value); await snapshot1.FetchAttributesAsync(); await snapshot2.FetchAttributesAsync(); await blob.FetchAttributesAsync(); AssertAreEqual(snapshot1.Properties, blob.Properties); CloudPageBlob snapshot1Clone = new CloudPageBlob(new Uri(blob.Uri + "?snapshot=" + snapshot1.SnapshotTime.Value.ToString("O")), blob.ServiceClient.Credentials); Assert.IsNotNull(snapshot1Clone.SnapshotTime, "Snapshot clone does not have SnapshotTime set"); Assert.AreEqual(snapshot1.SnapshotTime.Value, snapshot1Clone.SnapshotTime.Value); await snapshot1Clone.FetchAttributesAsync(); AssertAreEqual(snapshot1.Properties, snapshot1Clone.Properties); CloudPageBlob snapshotCopy = container.GetPageBlobReference("blob2"); await snapshotCopy.StartCopyFromBlobAsync(TestHelper.Defiddler(snapshot1.Uri)); await WaitForCopyAsync(snapshotCopy); Assert.AreEqual(CopyStatus.Success, snapshotCopy.CopyState.Status); await TestHelper.ExpectedExceptionAsync <InvalidOperationException>( async() => await snapshot1.OpenWriteAsync(1024), "Trying to write to a blob snapshot should fail"); using (Stream snapshotStream = (await snapshot1.OpenReadAsync()).AsStreamForRead()) { snapshotStream.Seek(0, SeekOrigin.End); TestHelper.AssertStreamsAreEqual(originalData, snapshotStream); } await blob.CreateAsync(1024); using (Stream snapshotStream = (await snapshot1.OpenReadAsync()).AsStreamForRead()) { snapshotStream.Seek(0, SeekOrigin.End); TestHelper.AssertStreamsAreEqual(originalData, snapshotStream); } BlobResultSegment resultSegment = await container.ListBlobsSegmentedAsync(null, true, BlobListingDetails.All, null, null, null, null); List <IListBlobItem> blobs = resultSegment.Results.ToList(); Assert.AreEqual(4, blobs.Count); AssertAreEqual(snapshot1, (ICloudBlob)blobs[0]); AssertAreEqual(snapshot2, (ICloudBlob)blobs[1]); AssertAreEqual(blob, (ICloudBlob)blobs[2]); AssertAreEqual(snapshotCopy, (ICloudBlob)blobs[3]); } finally { container.DeleteIfExistsAsync().AsTask().Wait(); } }