Пример #1
0
        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);
            }
        }
Пример #2
0
        public async Task GetBlockListAsync_LongBlock()
        {
            // Arange
            var blobContainerClient = blobServiceClient.GetBlobContainerClient(Guid.NewGuid().ToString());
            await blobContainerClient.CreateIfNotExistsAsync();

            var blobName = Guid.NewGuid().ToString();

            var blobClient = blobContainerClient.GetBlockBlobClient(blobName);

            const long bigBlockSize = int.MaxValue + 1024L;

            var blockId0 = Convert.ToBase64String(Guid.NewGuid().ToByteArray());

            using (var stream = new Storage.Tests.Shared.PredictableStream(length: bigBlockSize))
            {
                await blobClient.StageBlockAsync(blockId0, stream);
            }
            await blobClient.CommitBlockListAsync(new string[] { blockId0 });

            // Act
            Response <BlockList> response = await blobClient.GetBlockListAsync();

            // Assert
            Assert.AreEqual(1, response.Value.CommittedBlocks.Count());
            Assert.AreEqual(blockId0, response.Value.CommittedBlocks.First().Name);
            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
        }