public async Task CloudFileWriteRangeAsync() { byte[] buffer = GetRandomBuffer(4 * 1024 * 1024); #if NETCORE MD5 md5 = MD5.Create(); string contentMD5 = Convert.ToBase64String(md5.ComputeHash(buffer)); #else CryptographicHash hasher = HashAlgorithmProvider.OpenAlgorithm("MD5").CreateHash(); hasher.Append(buffer.AsBuffer()); string contentMD5 = CryptographicBuffer.EncodeToBase64String(hasher.GetValueAndReset()); #endif CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); await file.CreateAsync(4 * 1024 * 1024); using (MemoryStream memoryStream = new MemoryStream()) { await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>( async() => await file.WriteRangeAsync(memoryStream, 0, null), "Zero-length WriteRange should fail"); } using (MemoryStream resultingData = new MemoryStream()) { using (MemoryStream memoryStream = new MemoryStream(buffer)) { OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await file.WriteRangeAsync(memoryStream, 512, null, null, null, opContext), opContext, "Writing out-of-range ranges should fail", HttpStatusCode.RequestedRangeNotSatisfiable, "InvalidRange"); memoryStream.Seek(0, SeekOrigin.Begin); await file.WriteRangeAsync(memoryStream, 0, contentMD5); resultingData.Write(buffer, 0, buffer.Length); int offset = buffer.Length - 1024; memoryStream.Seek(offset, SeekOrigin.Begin); await TestHelper.ExpectedExceptionAsync( async() => await file.WriteRangeAsync(memoryStream, 0, contentMD5, null, null, opContext), opContext, "Invalid MD5 should fail with mismatch", HttpStatusCode.BadRequest, "Md5Mismatch"); memoryStream.Seek(offset, SeekOrigin.Begin); await file.WriteRangeAsync(memoryStream, 0, null); resultingData.Seek(0, SeekOrigin.Begin); resultingData.Write(buffer, offset, buffer.Length - offset); offset = buffer.Length - 2048; memoryStream.Seek(offset, SeekOrigin.Begin); await file.WriteRangeAsync(memoryStream, 1024, null); resultingData.Seek(1024, SeekOrigin.Begin); resultingData.Write(buffer, offset, buffer.Length - offset); } using (MemoryStream fileData = new MemoryStream()) { await file.DownloadToStreamAsync(fileData); Assert.AreEqual(resultingData.Length, fileData.Length); Assert.IsTrue(fileData.ToArray().SequenceEqual(resultingData.ToArray())); } } } finally { share.DeleteIfExistsAsync().Wait(); } }
public async Task CloudFileSetPropertiesAsync() { CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); await file.CreateAsync(1024); string eTag = file.Properties.ETag; DateTimeOffset lastModified = file.Properties.LastModified.Value; await Task.Delay(1000); file.Properties.CacheControl = "no-transform"; file.Properties.ContentEncoding = "gzip"; file.Properties.ContentLanguage = "tr,en"; file.Properties.ContentMD5 = "MDAwMDAwMDA="; file.Properties.ContentType = "text/html"; await file.SetPropertiesAsync(); Assert.IsTrue(file.Properties.LastModified > lastModified); Assert.AreNotEqual(eTag, file.Properties.ETag); CloudFile file2 = share.GetRootDirectoryReference().GetFileReference("file1"); await file2.FetchAttributesAsync(); Assert.AreEqual("no-transform", file2.Properties.CacheControl); Assert.AreEqual("gzip", file2.Properties.ContentEncoding); Assert.AreEqual("tr,en", file2.Properties.ContentLanguage); Assert.AreEqual("MDAwMDAwMDA=", file2.Properties.ContentMD5); Assert.AreEqual("text/html", file2.Properties.ContentType); CloudFile file3 = share.GetRootDirectoryReference().GetFileReference("file1"); using (MemoryStream stream = new MemoryStream()) { FileRequestOptions options = new FileRequestOptions() { DisableContentMD5Validation = true, }; await file3.DownloadToStreamAsync(stream, null, options, null); } AssertAreEqual(file2.Properties, file3.Properties); CloudFileDirectory rootDirectory = share.GetRootDirectoryReference(); IEnumerable <IListFileItem> results = await ListFilesAndDirectoriesAsync(rootDirectory, null, null, null, null); CloudFile file4 = (CloudFile)results.First(); Assert.AreEqual(file2.Properties.Length, file4.Properties.Length); CloudFile file5 = share.GetRootDirectoryReference().GetFileReference("file1"); Assert.IsNull(file5.Properties.ContentMD5); byte[] target = new byte[4]; await file5.DownloadRangeToByteArrayAsync(target, 0, 0, 4); Assert.AreEqual("MDAwMDAwMDA=", file5.Properties.ContentMD5); } finally { share.DeleteIfExistsAsync().Wait(); } }
public async Task CloudFileWriteRangeAsync() { byte[] buffer = GetRandomBuffer(4 * 1024 * 1024); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); await file.CreateAsync(4 * 1024 * 1024); using (MemoryStream memoryStream = new MemoryStream()) { await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>( async() => await file.WriteRangeAsync(memoryStream, 0, null), "Zero-length WriteRange should fail"); memoryStream.SetLength(4 * 1024 * 1024 + 1); await TestHelper.ExpectedExceptionAsync <ArgumentOutOfRangeException>( async() => await file.WriteRangeAsync(memoryStream, 0, null), ">4MB WriteRange should fail"); } using (MemoryStream resultingData = new MemoryStream()) { using (MemoryStream memoryStream = new MemoryStream(buffer)) { OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await file.WriteRangeAsync(memoryStream, 512, null, null, null, opContext), opContext, "Writing out-of-range ranges should fail", HttpStatusCode.RequestedRangeNotSatisfiable, "InvalidFileRange"); memoryStream.Seek(0, SeekOrigin.Begin); await file.WriteRangeAsync(memoryStream, 0, null); resultingData.Write(buffer, 0, buffer.Length); int offset = buffer.Length - 1024; memoryStream.Seek(offset, SeekOrigin.Begin); await file.WriteRangeAsync(memoryStream, 0, null); resultingData.Seek(0, SeekOrigin.Begin); resultingData.Write(buffer, offset, buffer.Length - offset); offset = buffer.Length - 2048; memoryStream.Seek(offset, SeekOrigin.Begin); await file.WriteRangeAsync(memoryStream, 1024, null); resultingData.Seek(1024, SeekOrigin.Begin); resultingData.Write(buffer, offset, buffer.Length - offset); } using (MemoryStream fileData = new MemoryStream()) { await file.DownloadToStreamAsync(fileData); Assert.AreEqual(resultingData.Length, fileData.Length); Assert.IsTrue(fileData.ToArray().SequenceEqual(resultingData.ToArray())); } } } finally { share.DeleteIfExistsAsync().Wait(); } }
public async Task CloudFileListRangesAsync() { byte[] buffer = GetRandomBuffer(1024); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); await file.CreateAsync(4 * 1024); using (MemoryStream memoryStream = new MemoryStream(buffer)) { await file.WriteRangeAsync(memoryStream, 512, null); } using (MemoryStream memoryStream = new MemoryStream(buffer)) { await file.WriteRangeAsync(memoryStream, 3 * 1024, null); } await file.ClearRangeAsync(1024, 1024); await file.ClearRangeAsync(0, 512); IEnumerable <FileRange> fileRanges = await file.ListRangesAsync(); List <string> expectedFileRanges = new List <string>() { new FileRange(512, 1023).ToString(), new FileRange(3 * 1024, 4 * 1024 - 1).ToString(), }; foreach (FileRange fileRange in fileRanges) { Assert.IsTrue(expectedFileRanges.Remove(fileRange.ToString())); } Assert.AreEqual(0, expectedFileRanges.Count); fileRanges = await file.ListRangesAsync(1024, 1024, null, null, null); Assert.AreEqual(0, fileRanges.Count()); fileRanges = await file.ListRangesAsync(512, 3 * 1024, null, null, null); expectedFileRanges = new List <string>() { new FileRange(512, 1023).ToString(), new FileRange(3 * 1024, 7 * 512 - 1).ToString(), }; foreach (FileRange fileRange in fileRanges) { Assert.IsTrue(expectedFileRanges.Remove(fileRange.ToString())); } Assert.AreEqual(0, expectedFileRanges.Count); OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await file.ListRangesAsync(1024, null, null, null, opContext), opContext, "List Ranges with an offset but no count should fail", HttpStatusCode.Unused); Assert.IsInstanceOfType(opContext.LastResult.Exception.InnerException, typeof(ArgumentNullException)); } finally { share.DeleteIfExistsAsync().Wait(); } }
public async Task CloudFileShareTryGetValuePermissions() { CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); FileSharePermissions permissions = await share.GetPermissionsAsync(); Assert.AreEqual(0, permissions.SharedAccessPolicies.Count); // We do not have precision at milliseconds level. Hence, we need // to recreate the start DateTime to be able to compare it later. DateTime start = DateTime.UtcNow; start = new DateTime(start.Year, start.Month, start.Day, start.Hour, start.Minute, start.Second, DateTimeKind.Utc); DateTime expiry = start.AddMinutes(30); KeyValuePair <String, SharedAccessFilePolicy> sharedAccessPolicy = new KeyValuePair <string, SharedAccessFilePolicy>("key1", new SharedAccessFilePolicy() { SharedAccessStartTime = start, SharedAccessExpiryTime = expiry, Permissions = SharedAccessFilePermissions.List, }); DateTime start2 = DateTime.UtcNow; start2 = new DateTime(start2.Year, start2.Month, start2.Day, start2.Hour, start2.Minute, start2.Second, DateTimeKind.Utc); DateTime expiry2 = start2.AddMinutes(30); KeyValuePair <String, SharedAccessFilePolicy> sharedAccessPolicy2 = new KeyValuePair <string, SharedAccessFilePolicy>("key2", new SharedAccessFilePolicy() { SharedAccessStartTime = start2, SharedAccessExpiryTime = expiry2, Permissions = SharedAccessFilePermissions.List, }); permissions.SharedAccessPolicies.Add(sharedAccessPolicy); permissions.SharedAccessPolicies.Add(sharedAccessPolicy2); await share.SetPermissionsAsync(permissions); await Task.Delay(3 * 1000); Assert.AreEqual(2, permissions.SharedAccessPolicies.Count); permissions = await share.GetPermissionsAsync(); SharedAccessFilePolicy retrPolicy; permissions.SharedAccessPolicies.TryGetValue("key1", out retrPolicy); Assert.AreEqual(sharedAccessPolicy.Value.Permissions, retrPolicy.Permissions); Assert.AreEqual(sharedAccessPolicy.Value.SharedAccessStartTime, retrPolicy.SharedAccessStartTime); Assert.AreEqual(sharedAccessPolicy.Value.SharedAccessExpiryTime, retrPolicy.SharedAccessExpiryTime); SharedAccessFilePolicy retrPolicy2; permissions.SharedAccessPolicies.TryGetValue("key2", out retrPolicy2); Assert.AreEqual(sharedAccessPolicy2.Value.Permissions, retrPolicy2.Permissions); Assert.AreEqual(sharedAccessPolicy2.Value.SharedAccessStartTime, retrPolicy2.SharedAccessStartTime); Assert.AreEqual(sharedAccessPolicy2.Value.SharedAccessExpiryTime, retrPolicy2.SharedAccessExpiryTime); } finally { share.DeleteIfExistsAsync().Wait(); } }
public async Task FileWriteStreamFlushTestAsync() { byte[] buffer = GetRandomBuffer(512); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); file.StreamWriteSizeInBytes = 1024; using (MemoryStream wholeFile = new MemoryStream()) { FileRequestOptions options = new FileRequestOptions() { StoreFileContentMD5 = true }; OperationContext opContext = new OperationContext(); using (ICloudFileStream fileStream = await file.OpenWriteAsync(4 * 512, null, options, opContext)) { for (int i = 0; i < 3; i++) { await fileStream.WriteAsync(buffer.AsBuffer()); await wholeFile.WriteAsync(buffer, 0, buffer.Length); } Assert.AreEqual(2, opContext.RequestResults.Count); await fileStream.FlushAsync(); Assert.AreEqual(3, opContext.RequestResults.Count); await fileStream.FlushAsync(); Assert.AreEqual(3, opContext.RequestResults.Count); await fileStream.WriteAsync(buffer.AsBuffer()); await wholeFile.WriteAsync(buffer, 0, buffer.Length); Assert.AreEqual(3, opContext.RequestResults.Count); await fileStream.CommitAsync(); Assert.AreEqual(5, opContext.RequestResults.Count); } Assert.AreEqual(5, opContext.RequestResults.Count); using (MemoryOutputStream downloadedFile = new MemoryOutputStream()) { await file.DownloadToStreamAsync(downloadedFile); TestHelper.AssertStreamsAreEqual(wholeFile, downloadedFile.UnderlyingStream); } } } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudFileSASSharedProtocolsQueryParamAsync() { CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file; SharedAccessFilePolicy policy = new SharedAccessFilePolicy() { Permissions = SharedAccessFilePermissions.Read, SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5), SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30), }; CloudFile fileWithKey = share.GetRootDirectoryReference().GetFileReference("filefile"); byte[] data = new byte[] { 0x1, 0x2, 0x3, 0x4 }; byte[] target = new byte[4]; await fileWithKey.UploadFromByteArrayAsync(data, 0, 4); foreach (SharedAccessProtocol?protocol in new SharedAccessProtocol?[] { null, SharedAccessProtocol.HttpsOrHttp, SharedAccessProtocol.HttpsOnly }) { string fileToken = fileWithKey.GetSharedAccessSignature(policy, null, null, protocol, null); StorageCredentials fileSAS = new StorageCredentials(fileToken); Uri fileSASUri = new Uri(fileWithKey.Uri + fileSAS.SASToken); StorageUri fileSASStorageUri = new StorageUri(new Uri(fileWithKey.StorageUri.PrimaryUri + fileSAS.SASToken), new Uri(fileWithKey.StorageUri.SecondaryUri + fileSAS.SASToken)); int httpPort = fileSASUri.Port; int securePort = 443; if (!string.IsNullOrEmpty(TestBase.TargetTenantConfig.FileSecurePortOverride)) { securePort = Int32.Parse(TestBase.TargetTenantConfig.FileSecurePortOverride); } var schemesAndPorts = new[] { new { scheme = "HTTP", port = httpPort }, new { scheme = "HTTPS", port = securePort } }; foreach (var item in schemesAndPorts) { fileSASUri = TransformSchemeAndPort(fileSASUri, item.scheme, item.port); fileSASStorageUri = new StorageUri(TransformSchemeAndPort(fileSASStorageUri.PrimaryUri, item.scheme, item.port), TransformSchemeAndPort(fileSASStorageUri.SecondaryUri, item.scheme, item.port)); if (protocol.HasValue && protocol == SharedAccessProtocol.HttpsOnly && string.CompareOrdinal(item.scheme, "HTTP") == 0) { file = new CloudFile(fileSASUri); OperationContext context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await file.FetchAttributesAsync(null /* accessCondition */, null /* options */, context), context, "Access a file using SAS with a shared protocols that does not match", HttpStatusCode.Unused, ""); file = new CloudFile(fileSASStorageUri, null); context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await file.FetchAttributesAsync(null /* accessCondition */, null /* options */, context), context, "Access a file using SAS with a shared protocols that does not match", HttpStatusCode.Unused, ""); } else { file = new CloudFile(fileSASUri); await file.DownloadRangeToByteArrayAsync(target, 0, 0, 4, null, null, null); for (int i = 0; i < 4; i++) { Assert.AreEqual(data[i], target[i]); } file = new CloudFile(fileSASStorageUri, null); await file.DownloadRangeToByteArrayAsync(target, 0, 0, 4, null, null, null); for (int i = 0; i < 4; i++) { Assert.AreEqual(data[i], target[i]); } } } } } finally { share.DeleteIfExistsAsync().Wait(); } }
public async Task FileReadLockToETagTestAsync() { byte[] outBuffer = new byte[1 * 1024 * 1024]; byte[] buffer = GetRandomBuffer(2 * outBuffer.Length); CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file1"); file.StreamMinimumReadSizeInBytes = outBuffer.Length; using (MemoryStream wholeFile = new MemoryStream(buffer)) { await file.UploadFromStreamAsync(wholeFile.AsInputStream()); } OperationContext opContext = new OperationContext(); using (IRandomAccessStreamWithContentType fileStream = await file.OpenReadAsync(null, null, opContext)) { Stream fileStreamForRead = fileStream.AsStreamForRead(); await fileStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length); await file.SetMetadataAsync(); await TestHelper.ExpectedExceptionAsync( async() => await fileStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length), opContext, "File read stream should fail if file is modified during read", HttpStatusCode.PreconditionFailed); } opContext = new OperationContext(); using (IRandomAccessStreamWithContentType fileStream = await file.OpenReadAsync(null, null, opContext)) { Stream fileStreamForRead = fileStream.AsStreamForRead(); long length = fileStreamForRead.Length; await file.SetMetadataAsync(); await TestHelper.ExpectedExceptionAsync( async() => await fileStreamForRead.ReadAsync(outBuffer, 0, outBuffer.Length), opContext, "File read stream should fail if file is modified during read", HttpStatusCode.PreconditionFailed); } /* * opContext = new OperationContext(); * AccessCondition accessCondition = AccessCondition.GenerateIfNotModifiedSinceCondition(DateTimeOffset.Now.Subtract(TimeSpan.FromHours(1))); * await file.SetMetadataAsync(); * await TestHelper.ExpectedExceptionAsync( * async () => await file.OpenReadAsync(accessCondition, null, opContext), * opContext, * "File read stream should fail if file is modified during read", * HttpStatusCode.PreconditionFailed); */ } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task CloudFileClientMaximumExecutionTimeoutShouldNotBeHonoredForStreamsAsync() { CloudFileClient fileClient = GenerateCloudFileClient(); CloudFileShare share = fileClient.GetShareReference(Guid.NewGuid().ToString("N")); CloudFileDirectory rootDirectory = share.GetRootDirectoryReference(); byte[] buffer = FileTestBase.GetRandomBuffer(1024 * 1024); try { await share.CreateAsync(); fileClient.DefaultRequestOptions.MaximumExecutionTime = TimeSpan.FromSeconds(30); CloudFile file = rootDirectory.GetFileReference("file"); file.StreamMinimumReadSizeInBytes = 1024 * 1024; using (ICloudFileStream fileStream = await file.OpenWriteAsync(8 * 1024 * 1024)) { Stream fos = fileStream.AsStreamForWrite(); DateTime start = DateTime.Now; for (int i = 0; i < 7; i++) { await fos.WriteAsync(buffer, 0, buffer.Length); } // Sleep to ensure we are over the Max execution time when we do the last write int msRemaining = (int)(fileClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds; if (msRemaining > 0) { await Task.Delay(msRemaining); } await fos.WriteAsync(buffer, 0, buffer.Length); await fileStream.CommitAsync(); } using (IRandomAccessStreamWithContentType fileStream = await file.OpenReadAsync()) { Stream fis = fileStream.AsStreamForRead(); DateTime start = DateTime.Now; int total = 0; while (total < 7 * 1024 * 1024) { total += await fis.ReadAsync(buffer, 0, buffer.Length); } // Sleep to ensure we are over the Max execution time when we do the last read int msRemaining = (int)(fileClient.DefaultRequestOptions.MaximumExecutionTime.Value - (DateTime.Now - start)).TotalMilliseconds; if (msRemaining > 0) { await Task.Delay(msRemaining); } while (true) { int count = await fis.ReadAsync(buffer, 0, buffer.Length); total += count; if (count == 0) { break; } } } } finally { fileClient.DefaultRequestOptions.MaximumExecutionTime = null; share.DeleteIfExistsAsync().AsTask().Wait(); } }
private static async Task CloudFileCopyAsync(bool sourceIsSas, bool destinationIsSas) { CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); // Create Source on server CloudFile source = share.GetRootDirectoryReference().GetFileReference("source"); string data = "String data"; await UploadTextAsync(source, data, Encoding.UTF8); source.Metadata["Test"] = "value"; await source.SetMetadataAsync(); // Create Destination on server CloudFile destination = share.GetRootDirectoryReference().GetFileReference("destination"); await destination.CreateAsync(1); CloudFile copySource = source; CloudFile copyDestination = destination; if (sourceIsSas) { // Source SAS must have read permissions SharedAccessFilePermissions permissions = SharedAccessFilePermissions.Read; SharedAccessFilePolicy policy = new SharedAccessFilePolicy() { SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5), SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30), Permissions = permissions, }; string sasToken = source.GetSharedAccessSignature(policy); // Get source StorageCredentials credentials = new StorageCredentials(sasToken); copySource = new CloudFile(credentials.TransformUri(source.Uri)); } if (destinationIsSas) { Assert.IsTrue(sourceIsSas); // Destination SAS must have write permissions SharedAccessFilePermissions permissions = SharedAccessFilePermissions.Write; SharedAccessFilePolicy policy = new SharedAccessFilePolicy() { SharedAccessStartTime = DateTimeOffset.UtcNow.AddMinutes(-5), SharedAccessExpiryTime = DateTimeOffset.UtcNow.AddMinutes(30), Permissions = permissions, }; string sasToken = destination.GetSharedAccessSignature(policy); // Get destination StorageCredentials credentials = new StorageCredentials(sasToken); copyDestination = new CloudFile(credentials.TransformUri(destination.Uri)); } // Start copy and wait for completion string copyId = await copyDestination.StartCopyAsync(TestHelper.Defiddler(copySource)); await WaitForCopyAsync(destination); // Check original file references for equality Assert.AreEqual(CopyStatus.Success, destination.CopyState.Status); Assert.AreEqual(source.Uri.AbsolutePath, destination.CopyState.Source.AbsolutePath); Assert.AreEqual(data.Length, destination.CopyState.TotalBytes); Assert.AreEqual(data.Length, destination.CopyState.BytesCopied); Assert.AreEqual(copyId, destination.CopyState.CopyId); Assert.IsTrue(destination.CopyState.CompletionTime > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); if (!destinationIsSas) { // Abort Copy is not supported for SAS destination OperationContext context = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await copyDestination.AbortCopyAsync(copyId, null, null, context), context, "Aborting a copy operation after completion should fail", HttpStatusCode.Conflict, "NoPendingCopyOperation"); } await source.FetchAttributesAsync(); Assert.IsNotNull(destination.Properties.ETag); Assert.AreNotEqual(source.Properties.ETag, destination.Properties.ETag); Assert.IsTrue(destination.Properties.LastModified > DateTimeOffset.UtcNow.Subtract(TimeSpan.FromMinutes(1))); string copyData = await DownloadTextAsync(destination, Encoding.UTF8); Assert.AreEqual(data, copyData, "Data inside copy of file not equal."); await destination.FetchAttributesAsync(); FileProperties prop1 = destination.Properties; FileProperties 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", destination.Metadata["Test"], false, "Copied metadata not same"); await destination.DeleteAsync(); await source.DeleteAsync(); } finally { share.DeleteIfExistsAsync().AsTask().Wait(); } }
public async Task FileDisableContentMD5ValidationTestAsync() { byte[] buffer = new byte[1024]; Random random = new Random(); random.NextBytes(buffer); FileRequestOptions optionsWithNoMD5 = new FileRequestOptions() { DisableContentMD5Validation = true, StoreFileContentMD5 = true, }; FileRequestOptions optionsWithMD5 = new FileRequestOptions() { DisableContentMD5Validation = false, StoreFileContentMD5 = true, }; CloudFileShare share = GetRandomShareReference(); try { await share.CreateAsync(); CloudFile file = share.GetRootDirectoryReference().GetFileReference("file2"); using (Stream stream = new MemoryStream(buffer)) { await file.UploadFromStreamAsync(stream, null, optionsWithMD5, null); } using (Stream stream = new MemoryStream()) { await file.DownloadToStreamAsync(stream, null, optionsWithMD5, null); await file.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null); using (var fileStream = await file.OpenReadAsync(null, optionsWithMD5, null)) { Stream fileStreamForRead = fileStream; int read; do { read = await fileStreamForRead.ReadAsync(buffer, 0, buffer.Length); }while (read > 0); } using (var fileStream = await file.OpenReadAsync(null, optionsWithNoMD5, null)) { Stream fileStreamForRead = fileStream; int read; do { read = await fileStreamForRead.ReadAsync(buffer, 0, buffer.Length); }while (read > 0); } file.Properties.ContentMD5 = "MDAwMDAwMDA="; await file.SetPropertiesAsync(); OperationContext opContext = new OperationContext(); await TestHelper.ExpectedExceptionAsync( async() => await file.DownloadToStreamAsync(stream, null, optionsWithMD5, opContext), opContext, "Downloading a file with invalid MD5 should fail", HttpStatusCode.OK); await file.DownloadToStreamAsync(stream, null, optionsWithNoMD5, null); using (var fileStream = await file.OpenReadAsync(null, optionsWithMD5, null)) { Stream fileStreamForRead = fileStream; TestHelper.ExpectedException <IOException>( () => { int read; do { read = fileStreamForRead.Read(buffer, 0, buffer.Length); }while (read > 0); }, "Downloading a file with invalid MD5 should fail"); } using (var fileStream = await file.OpenReadAsync(null, optionsWithNoMD5, null)) { Stream fileStreamForRead = fileStream; int read; do { read = await fileStreamForRead.ReadAsync(buffer, 0, buffer.Length); }while (read > 0); } } } finally { share.DeleteIfExistsAsync().Wait(); } }