Esempio n. 1
0
        public async Task FileUploadFromStreamTestAsync()
        {
            byte[]         buffer = GetRandomBuffer(2 * 1024);
            CloudFileShare share  = GetRandomShareReference();

            try
            {
                await share.CreateAsync();

                CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
                using (MemoryStream srcStream = new MemoryStream(buffer))
                {
                    await file.UploadFromStreamAsync(srcStream);

                    byte[]       testBuffer = new byte[2048];
                    MemoryStream dstStream  = new MemoryStream(testBuffer);
                    await file.DownloadRangeToStreamAsync(dstStream, null, null);

                    TestHelper.AssertStreamsAreEqual(srcStream, dstStream);
                }
            }
            finally
            {
                share.DeleteIfExistsAsync().Wait();
            }
        }
Esempio n. 2
0
        public async Task FileOpenWriteTestAsync()
        {
            byte[]         buffer = GetRandomBuffer(2 * 1024);
            CloudFileShare share  = GetRandomShareReference();

            try
            {
                await share.CreateAsync();

                CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
                using (CloudFileStream fileStream = await file.OpenWriteAsync(2048))
                {
                    Stream fileStreamForWrite = fileStream;
                    await fileStreamForWrite.WriteAsync(buffer, 0, 2048);

                    await fileStreamForWrite.FlushAsync();

                    byte[]       testBuffer = new byte[2048];
                    MemoryStream dstStream  = new MemoryStream(testBuffer);
                    await file.DownloadRangeToStreamAsync(dstStream, null, null);

                    MemoryStream memStream = new MemoryStream(buffer);
                    TestHelper.AssertStreamsAreEqual(memStream, dstStream);
                }
            }
            finally
            {
                share.DeleteIfExistsAsync().Wait();
            }
        }
Esempio n. 3
0
        public async Task FileDownloadToStreamRangeTestAsync()
        {
            byte[]         buffer = GetRandomBuffer(2 * 1024);
            CloudFileShare share  = GetRandomShareReference();

            try
            {
                await share.CreateAsync();

                CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1");
                using (MemoryStream wholeFile = new MemoryStream(buffer))
                {
                    await file.UploadFromStreamAsync(wholeFile);

                    byte[]       testBuffer = new byte[1024];
                    MemoryStream fileStream = new MemoryStream(testBuffer);
                    Exception    ex         = await TestHelper.ExpectedExceptionAsync <Exception>(
                        async() => await file.DownloadRangeToStreamAsync(fileStream, 0, 0),
                        "Requesting 0 bytes when downloading range should not work");

                    Assert.IsInstanceOfType(ex.InnerException, typeof(ArgumentOutOfRangeException));
                    await file.DownloadRangeToStreamAsync(fileStream, 0, 1024);

                    Assert.AreEqual(fileStream.Position, 1024);
                    TestHelper.AssertStreamsAreEqualAtIndex(fileStream, wholeFile, 0, 0, 1024);

                    CloudFile    file2       = share.GetRootDirectoryReference().GetFileReference("file1");
                    MemoryStream fileStream2 = new MemoryStream(testBuffer);
                    ex = await TestHelper.ExpectedExceptionAsync <Exception>(
                        async() => await file2.DownloadRangeToStreamAsync(fileStream, 1024, 0),
                        "Requesting 0 bytes when downloading range should not work");

                    Assert.IsInstanceOfType(ex.InnerException, typeof(ArgumentOutOfRangeException));
                    await file2.DownloadRangeToStreamAsync(fileStream2, 1024, 1024);

                    TestHelper.AssertStreamsAreEqualAtIndex(fileStream2, wholeFile, 0, 1024, 1024);

                    AssertAreEqual(file, file2);
                }
            }
            finally
            {
                share.DeleteIfExistsAsync().Wait();
            }
        }
Esempio n. 4
0
        public async Task FileUploadWithoutMD5ValidationAndStoreFileContentTestAsync()
        {
            byte[]         buffer = GetRandomBuffer(2 * 1024);
            CloudFileShare share  = GetRandomShareReference();

            try
            {
                await share.CreateAsync();

                CloudFile          file    = share.GetRootDirectoryReference().GetFileReference("file1");
                FileRequestOptions options = new FileRequestOptions();
                options.DisableContentMD5Validation = false;
                options.StoreFileContentMD5         = false;
                OperationContext context = new OperationContext();
                using (MemoryStream srcStream = new MemoryStream(buffer))
                {
                    await file.UploadFromStreamAsync(srcStream, null, options, context);

                    await file.FetchAttributesAsync();

                    string md5 = file.Properties.ContentMD5;
                    file.Properties.ContentMD5 = "MDAwMDAwMDA=";
                    await file.SetPropertiesAsync(null, options, context);

                    byte[]       testBuffer = new byte[2048];
                    MemoryStream dstStream  = new MemoryStream(testBuffer);
                    await TestHelper.ExpectedExceptionAsync(async() => await file.DownloadRangeToStreamAsync(dstStream, 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 file.SetPropertiesAsync(null, options, context);

                    byte[]       testBuffer2 = new byte[2048];
                    MemoryStream dstStream2  = new MemoryStream(testBuffer2);
                    await file.DownloadRangeToStreamAsync(dstStream2, null, null, null, options, context);
                }
            }
            finally
            {
                share.DeleteIfExistsAsync().Wait();
            }
        }