[Storage] Enable some of large payload tests. (Azure#19139)

* handle some tests.

* wip

Author: kasobol-msft

sdk/storage/Azure.Storage.Blobs/tests/LargeBlobTests.cs

@@ -2,6 +2,7 @@
 // Licensed under the MIT License.
 
 using System;
+using System.IO;
 using System.Linq;
 using System.Threading.Tasks;
 using Azure.Storage.Blobs.Models;
@@ -52,5 +53,69 @@ public async Task GetBlockListAsync_LongBlock()
             Assert.AreEqual(bigBlockSize, response.Value.CommittedBlocks.First().SizeLong);
             Assert.Throws<OverflowException>(() => _ = response.Value.CommittedBlocks.First().Size); // if no overflow then we didn't actually test handling of long lengths
         }
+
+        [Test]
+        public async Task CanHandleLongBlockBufferedUpload()
+        {
+            // Arrange
+            const long blockSize = int.MaxValue + 1024L;
+            const int numBlocks = 2;
+            Stream content = new Storage.Tests.Shared.PredictableStream(numBlocks * blockSize, revealsLength: false); // lack of Stream.Length forces buffered upload
+            var blobContainerClient = blobServiceClient.GetBlobContainerClient(Guid.NewGuid().ToString());
+            await blobContainerClient.CreateIfNotExistsAsync();
+            var blobName = Guid.NewGuid().ToString();
+            var blobClient = blobContainerClient.GetBlobClient(blobName);
+
+            // Act
+            await blobClient.UploadAsync(content, new BlobUploadOptions()
+            {
+                TransferOptions = new StorageTransferOptions
+                {
+                    InitialTransferSize = 1,
+                    MaximumTransferSize = blockSize,
+                    MaximumConcurrency = 1,
+                }
+            });
+            BlockList blockList = await blobContainerClient.GetBlockBlobClient(blobName).GetBlockListAsync();
+
+            // Assert
+            Assert.AreEqual(numBlocks * blockSize, blockList.BlobContentLength);
+            Assert.AreEqual(numBlocks, blockList.CommittedBlocks.Count());
+            foreach (var block in blockList.CommittedBlocks)
+            {
+                Assert.AreEqual(blockSize, block.SizeLong);
+            }
+        }
+
+        [Test]
+        public async Task CanHandleLongBlockBufferedUploadInParallel()
+        {
+            // Arrange
+            const long firstBlockSize = int.MaxValue + 1024L;
+            const long secondBlockSize = 1024L;
+            Stream content = new Storage.Tests.Shared.PredictableStream(firstBlockSize + secondBlockSize, revealsLength: false); // lack of Stream.Length forces buffered upload
+            var blobContainerClient = blobServiceClient.GetBlobContainerClient(Guid.NewGuid().ToString());
+            await blobContainerClient.CreateIfNotExistsAsync();
+            var blobName = Guid.NewGuid().ToString();
+            var blobClient = blobContainerClient.GetBlobClient(blobName);
+
+            // Act
+            await blobClient.UploadAsync(content, new BlobUploadOptions()
+            {
+                TransferOptions = new StorageTransferOptions
+                {
+                    InitialTransferSize = 1,
+                    MaximumTransferSize = firstBlockSize,
+                    MaximumConcurrency = 2,
+                }
+            });
+            BlockList blockList = await blobContainerClient.GetBlockBlobClient(blobName).GetBlockListAsync();
+
+            // Assert
+            Assert.AreEqual(firstBlockSize + secondBlockSize, blockList.BlobContentLength);
+            Assert.AreEqual(2, blockList.CommittedBlocks.Count());
+            Assert.AreEqual(firstBlockSize, blockList.CommittedBlocks.ElementAt(0).SizeLong);
+            Assert.AreEqual(secondBlockSize, blockList.CommittedBlocks.ElementAt(1).SizeLong);
+        }
     }
 }

sdk/storage/Azure.Storage.Blobs/tests/PartitionedUploaderTests.cs

@@ -248,40 +248,6 @@ public async Task AsyncUploadsAsSingleBlockIfUnderLimit()
             Assert.AreEqual(0, testPool.TotalRents);
         }
 
-        [Test]
-        [Explicit]
-        [Ignore("https://github.com/Azure/azure-sdk-for-net/issues/12312")]
-        public async Task CanHandleLongBlockBufferedUpload()
-        {
-            const long blockSize = int.MaxValue + 1024L;
-            const int numBlocks = 2;
-            Stream content = new Storage.Tests.Shared.PredictableStream(numBlocks * blockSize, revealsLength: false); // lack of Stream.Length forces buffered upload
-            TrackingArrayPool testPool = new TrackingArrayPool();
-            StagingSink sink = new StagingSink(false); // sink can't hold long blocks, and we don't need to look at their data anyway.
-
-            Mock<BlockBlobClient> clientMock = new Mock<BlockBlobClient>(MockBehavior.Strict, new Uri("http://mock"), new BlobClientOptions());
-            clientMock.SetupGet(c => c.ClientConfiguration.ClientDiagnostics).CallBase();
-            SetupInternalStaging(clientMock, sink);
-
-            var uploader = new PartitionedUploader<BlobUploadOptions, BlobContentInfo>(
-                BlockBlobClient.GetPartitionedUploaderBehaviors(clientMock.Object),
-                new StorageTransferOptions
-                {
-                    InitialTransferSize = 1,
-                    MaximumTransferSize = blockSize,
-                },
-                arrayPool: testPool);
-            Response<BlobContentInfo> info = await InvokeUploadAsync(uploader, content);
-
-            Assert.AreEqual(s_response, info);
-            Assert.AreEqual(numBlocks, sink.Staged.Count);
-            Assert.AreEqual(numBlocks, sink.Blocks.Length);
-            foreach (var block in sink.Staged.Values)
-            {
-                Assert.AreEqual(blockSize, block.StreamLength);
-            }
-        }
-
         [Test]
         public async Task NoBufferWhenUploadInSequenceOnSeekableStream()
         {

sdk/storage/Azure.Storage.Common/tests/PooledMemoryStreamTests.cs

@@ -56,10 +56,9 @@ public async Task ReadStream(int dataSize, int bufferPartitionSize)
         }
 
         [Test]
-        [Ignore("https://github.com/Azure/azure-sdk-for-net/issues/12312")]
         public void StreamCanHoldLongData()
         {
-            const long dataSize = 4000L * Constants.MB;
+            const long dataSize = (long)int.MaxValue + Constants.MB;
             const int bufferPartitionSize = 512 * Constants.MB;
             PredictableStream originalStream = new PredictableStream();
             PooledMemoryStream arrayPoolStream = PooledMemoryStream.BufferStreamPartitionInternal(originalStream, dataSize, dataSize, 0, _pool, bufferPartitionSize, false, default).EnsureCompleted();

sdk/storage/Azure.Storage.Common/tests/Shared/PredictableStream.cs

@@ -14,7 +14,7 @@ internal class PredictableStream : Stream
     {
         public override bool CanRead => true;
 
-        public override bool CanSeek => true;
+        public override bool CanSeek => _revealsLength;
 
         public override bool CanWrite => false;