public async Task SharePermissionsRawPermissions(string permissionsString) { // Arrange await using DisposingShare test = await GetTestShareAsync(); ShareSasBuilder blobSasBuilder = new ShareSasBuilder { StartsOn = Recording.UtcNow.AddHours(-1), ExpiresOn = Recording.UtcNow.AddHours(1), ShareName = test.Share.Name }; blobSasBuilder.SetPermissions( rawPermissions: permissionsString, normalize: true); StorageSharedKeyCredential sharedKeyCredential = new StorageSharedKeyCredential(TestConfigDefault.AccountName, TestConfigDefault.AccountKey); ShareUriBuilder blobUriBuilder = new ShareUriBuilder(test.Share.Uri) { Sas = blobSasBuilder.ToSasQueryParameters(sharedKeyCredential) }; ShareClient sasShareClient = new ShareClient(blobUriBuilder.ToUri(), GetOptions()); // Act await sasShareClient.GetRootDirectoryClient().GetPropertiesAsync(); }
public static ShareFileClient GetAzureFile(string folderName, string fileName) { string shareName = MyWebUtils.Application.ToLower(); string connectionString = Properties.Settings.Default.StorageConnectionString; ShareClient share = new ShareClient(connectionString, shareName); // Create the share if it doesn't already exist share.CreateIfNotExists(); if (share.Exists()) { ShareDirectoryClient subFolder = share.GetRootDirectoryClient(); foreach (string subFolderName in folderName.Split('\\')) { subFolder = subFolder.GetSubdirectoryClient(subFolderName); subFolder.CreateIfNotExists(); } return(subFolder.GetFileClient(fileName)); } return(null); }
/// <summary> /// Manage share metadata /// </summary> /// <param name="shareServiceClient"></param> /// <returns></returns> private static async Task ShareMetadataSample(ShareServiceClient shareServiceClient) { Console.WriteLine(); // Create the share name -- use a guid in the name so it's unique. string shareName = "demotest-" + Guid.NewGuid(); // Create Share Console.WriteLine("Create Share"); ShareClient shareClient = shareServiceClient.GetShareClient(shareName); await shareClient.CreateIfNotExistsAsync(); // Set share metadata Console.WriteLine("Set share metadata"); var metadata = new Dictionary <string, string> { { "key1", "value1" }, { "key2", "value2" } }; await shareClient.SetMetadataAsync(metadata); try { // Create Share Console.WriteLine("Create Share"); await shareClient.CreateIfNotExistsAsync(); // Fetch share attributes ShareProperties shareProperties = await shareClient.GetPropertiesAsync(); Console.WriteLine("Get share metadata:"); foreach (var keyValue in shareProperties.Metadata) { Console.WriteLine(" {0}: {1}", keyValue.Key, keyValue.Value); } Console.WriteLine(); } catch (RequestFailedException exRequest) { Common.WriteException(exRequest); Console.WriteLine( "Please make sure your storage account is specified correctly in the app.config - then restart the sample."); Console.WriteLine("Press any key to exit"); Console.ReadLine(); throw; } catch (Exception ex) { Console.WriteLine(" Exception thrown creating share."); Common.WriteException(ex); throw; } finally { // Delete share Console.WriteLine("Delete share"); await shareClient.DeleteIfExistsAsync(); } }
private static (ShareClient, ShareDirectoryClient, ShareFileClient) GetFileShareClients(string connectionString, string shareName, string dirName, string fileName) { ShareClient share = new ShareClient(connectionString, shareName); ShareDirectoryClient directory = share.GetDirectoryClient(dirName); ShareFileClient file = directory.GetFileClient(fileName); return(share, directory, file); }
public static async Task <FileShareScope> CreateShare(string connectionString) { var shareName = Guid.NewGuid().ToString("D"); var shareClient = new ShareClient(connectionString, shareName); await shareClient.CreateAsync().ConfigureAwait(false); return(new FileShareScope(shareClient, shareName)); }
private ShareClient InitializeClient() { ShareClient shareClient = new ShareClient( new Uri(this.uri), this.sasCred); return(shareClient); }
// <snippet_CreateShare> //------------------------------------------------- // Create a file share //------------------------------------------------- public async Task CreateShareAsync(string shareName) { // <snippet_CreateShareClient> // Get the connection string from app settings string connectionString = ConfigurationManager.AppSettings["StorageConnectionString"]; // Instantiate a ShareClient which will be used to create and manipulate the file share ShareClient share = new ShareClient(connectionString, shareName); // </snippet_CreateShareClient> // Create the share if it doesn't already exist await share.CreateIfNotExistsAsync(); // Ensure that the share exists if (await share.ExistsAsync()) { Console.WriteLine($"Share created: {share.Name}"); // Get a reference to the sample directory ShareDirectoryClient directory = share.GetDirectoryClient("CustomLogs"); // Create the directory if it doesn't already exist await directory.CreateIfNotExistsAsync(); // Ensure that the directory exists if (await directory.ExistsAsync()) { // Get a reference to a file object ShareFileClient file = directory.GetFileClient("Log1.txt"); // Ensure that the file exists if (await file.ExistsAsync()) { Console.WriteLine($"File exists: {file.Name}"); // Download the file ShareFileDownloadInfo download = await file.DownloadAsync(); // Save the data to a local file, overwrite if the file already exists using (FileStream stream = File.OpenWrite(@"downloadedLog1.txt")) { await download.Content.CopyToAsync(stream); await stream.FlushAsync(); stream.Close(); // Display where the file was saved Console.WriteLine($"File downloaded: {stream.Name}"); } } } } else { Console.WriteLine($"CreateShareAsync failed"); } }
static void Main(string[] args) { string downloadDirectory = args[0]; // Create a BlobServiceClient object which will be used to create a container client BlobServiceClient blobServiceClient = new BlobServiceClient(AZURE_STORAGE_CONNECTION_STRING); // Create a unique name for the container string containerName = "startupfiles"; // Create the container and return a container client object BlobContainerClient containerClient = blobServiceClient.GetBlobContainerClient(containerName); List <BlobItem> blobs = containerClient.GetBlobs().ToList(); // Download the blob files in parallel - maximum of 10 at a time } Parallel.ForEach(blobs, new ParallelOptions() { MaxDegreeOfParallelism = 10 }, blob => { string downloadFilePath = Path.Combine(downloadDirectory, blob.Name); BlobClient blobClient = containerClient.GetBlobClient(blob.Name); BlobDownloadInfo download = blobClient.Download(); using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath)) { download.Content.CopyTo(downloadFileStream); downloadFileStream.Close(); } }); string shareName = "startupfiles"; ShareClient shareClient = new ShareClient(AZURE_FILES_CONNECTION_STRING, shareName); if (shareClient.Exists()) { ShareDirectoryClient shareDirectoryClient = shareClient.GetRootDirectoryClient(); List <ShareFileItem> items = shareDirectoryClient.GetFilesAndDirectories().ToList(); foreach (ShareFileItem item in items) { if (!item.IsDirectory) { string downloadFilePath = Path.Combine(downloadDirectory, item.Name); ShareFileClient shareFileClient = shareDirectoryClient.GetFileClient(item.Name); ShareFileDownloadInfo download = shareFileClient.Download(); using (FileStream downloadFileStream = File.OpenWrite(downloadFilePath)) { download.Content.CopyTo(downloadFileStream); downloadFileStream.Close(); } } } } }
public async Task <DisposingShare> GetTestShareAsync(ShareServiceClient service = default, string shareName = default, IDictionary <string, string> metadata = default) { service ??= GetServiceClient_SharedKey(); metadata ??= new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); shareName ??= GetNewShareName(); ShareClient share = InstrumentClient(service.GetShareClient(shareName)); return(await DisposingShare.CreateAsync(share, metadata)); }
/// <summary> /// Azure File Storage constructor /// </summary> /// <param name="constr">The connection string</param> /// <param name="shareName">The name of the Share</param> public AzureFileStorage(string constr, string shareName) { FileShare = new ShareClient(constr, shareName); // Ensure that the share exists. if (!FileShare.Exists()) { throw new Exception("Cannot access Azure File Share: " + shareName + "."); } }
public void Setup() { SharedSetup(); ShareClient.Setup(s => s.GetRootDirectoryClient()) .Returns((_directory = new Mock <ShareDirectoryClient>()).Object); _directory.Setup(s => s.GetFileClient(It.IsAny <string>())) .Returns((_fileClient = new Mock <ShareFileClient>()).Object); }
/// <summary> /// Initializes a new instance of the <see cref="ShareLeaseClient"/> class. /// </summary> /// <param name="client"> /// A <see cref="ShareClient"/> representing the share being leased. /// </param> /// <param name="leaseId"> /// An optional lease ID. If no lease ID is provided, a random lease /// ID will be created. /// </param> public ShareLeaseClient(ShareClient client, string leaseId = null) { _share = client ?? throw Errors.ArgumentNull(nameof(client)); LeaseId = leaseId ?? CreateUniqueLeaseId(); ShareUriBuilder uriBuilder = new ShareUriBuilder(client.Uri) { ShareName = null }; }
public async Task FileSample() { // Instantiate a new FileServiceClient using a connection string. FileServiceClient fileServiceClient = new FileServiceClient(TestConfigurations.DefaultTargetTenant.ConnectionString); // Instantiate new ShareClient ShareClient shareClient = fileServiceClient.GetShareClient("myshare3"); try { // Create Share in the Service await shareClient.CreateAsync(); // Instantiate new DirectoryClient DirectoryClient directoryClient = shareClient.GetDirectoryClient("mydirectory"); // Create Directory in the Service await directoryClient.CreateAsync(); // Instantiate new FileClient FileClient fileClient = directoryClient.GetFileClient("myfile"); // Create File in the Service await fileClient.CreateAsync(maxSize : 1024); // Upload data to File using (FileStream fileStream = File.OpenRead("Samples/SampleSource.txt")) { await fileClient.UploadRangeAsync( writeType : FileRangeWriteType.Update, range : new HttpRange(0, 1024), content : fileStream); } // Download file using (FileStream fileStream = File.Create("SampleDestination.txt")) { Response <StorageFileDownloadInfo> downloadResponse = await fileClient.DownloadAsync(); await downloadResponse.Value.Content.CopyToAsync(fileStream); } // Delete File in the Service await fileClient.DeleteAsync(); // Delete Directory in the Service await directoryClient.DeleteAsync(); } finally { // Delete Share in the service await shareClient.DeleteAsync(); } }
public AzureFileShareCrawler( string uri, string path, string sharedAccessSignature) { this.uri = uri; this.path = path; this.sasCred = new AzureSasCredential(sharedAccessSignature); this.shareClient = InitializeClient(); }
public virtual Response <ShareClient> CreateShare( string shareName, IDictionary <string, string> metadata = default, int?quotaInGB = default, CancellationToken cancellationToken = default) { ShareClient share = GetShareClient(shareName); Response <ShareInfo> response = share.Create(metadata, quotaInGB, cancellationToken); return(Response.FromValue(share, response.GetRawResponse())); }
public virtual async Task <Response <ShareClient> > CreateShareAsync( string shareName, IDictionary <string, string> metadata = default, int?quotaInGB = default, CancellationToken cancellationToken = default) { ShareClient share = GetShareClient(shareName); Response <ShareInfo> response = await share.CreateAsync(metadata, quotaInGB, cancellationToken).ConfigureAwait(false); return(Response.FromValue(share, response.GetRawResponse())); }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequest req, ILogger log) { string connectionString = "DefaultEndpointsProtocol=https;AccountName=m10l2;AccountKey=jKxmGhpm9FWua8lWReXyt9gft5xConbXInXr8IRQj2Z1lWVL6YIWNl/pmqm3EQkdh7YgJlTRPakW8w2GiSfswg==;EndpointSuffix=core.windows.net"; string containerName = "test"; string queueName = "test"; string shareName = "test"; string blobName = $"{Guid.NewGuid().ToString()}.json"; string fileName = $"{Guid.NewGuid().ToString()}.json"; BlobContainerClient container = new BlobContainerClient(connectionString, containerName); BlobClient blob = container.GetBlobClient(blobName); Stream uploadStream = new MemoryStream(); req.Body.CopyTo(uploadStream); uploadStream.Position = 0; blob.Upload(uploadStream); Stream result = (await blob.DownloadAsync()).Value.Content; QueueClient queue = new QueueClient(connectionString, queueName); Stream messageStream = new MemoryStream(); req.Body.Position = 0; req.Body.CopyTo(messageStream); using (StreamReader sr = new StreamReader(messageStream)) { queue.SendMessage(sr.ReadToEnd()); } QueueMessage[] messages = (await queue.ReceiveMessagesAsync()).Value; ShareClient share = new ShareClient(connectionString, shareName); ShareDirectoryClient directory = share.GetRootDirectoryClient(); Stream fileStream = new MemoryStream(); req.Body.Position = 0; req.Body.CopyTo(fileStream); fileStream.Position = 0; ShareFileClient file = directory.GetFileClient(fileName); await file.CreateAsync(fileStream.Length); file.UploadRange(new HttpRange(0, fileStream.Length), fileStream); var downloadedFile = file.Download(); using (StreamReader sr = new StreamReader(downloadedFile.Value.Content)) { string uploadedFile = await sr.ReadToEndAsync(); return(new OkObjectResult(uploadedFile)); } }
private async Task UploadSchema(ShareClient client, string schemaPath, string targetDir, string targetFile) { var schemaStream = File.OpenRead(schemaPath); var directoryClient = client.GetDirectoryClient(targetDir); await directoryClient.CreateIfNotExistsAsync(); var fileClient = directoryClient.GetFileClient(targetFile); await fileClient.CreateAsync(schemaStream.Length); await fileClient.UploadAsync(schemaStream); }
// private CloudFileDirectory root; //DefaultEndpointsProtocol=https;AccountName=storagetajamarans;AccountKey=9nNsPth/T8BKQ75uFQTvYAEz3JtPFX8aiO7/fywMk5/BlXkI46IGX98dz0zODIO4UJH/0EjvS+giZQ/M6Rn+tQ==;EndpointSuffix=core.windows.net //9nNsPth/T8BKQ75uFQTvYAEz3JtPFX8aiO7/fywMk5/BlXkI46IGX98dz0zODIO4UJH/0EjvS+giZQ/M6Rn+tQ== public ServiceStorageFile(String keys) { // String key = ; /*CloudStorageAccount account = CloudStorageAccount.Parse(key); * * CloudFileClient fileClient = account.CreateCloudFileClient(); * * CloudFileShare shared = fileClient.GetShareReference("ejemplo"); * this.root = shared.GetRootDirectoryReference();*/ this.cliente = new ShareClient(keys, "ejemplo"); }
public virtual Response <ShareClient> CreateShare( string shareName, IDictionary <string, string> metadata = default, int?quotaInGB = default, CancellationToken cancellationToken = default) { ShareClient share = GetShareClient(shareName); Response <ShareInfo> response = share.CreateInternal( metadata, quotaInGB, accessTier: default,
public async Task DownloadAsync() { // Create a temporary Lorem Ipsum file on disk that we can upload string originalPath = CreateTempFile(SampleFileContent); // Get a temporary path on disk where we can download the file string downloadPath = CreateTempPath(); // Get a connection string to our Azure Storage account. string connectionString = ConnectionString; // Get a reference to a share named "sample-share" and then create it ShareClient share = new ShareClient(connectionString, Randomize("sample-share")); await share.CreateAsync(); try { // Get a reference to a directory named "sample-dir" and then create it DirectoryClient directory = share.GetDirectoryClient(Randomize("sample-dir")); await directory.CreateAsync(); // Get a reference to a file named "sample-file" in directory "sample-dir" FileClient file = directory.GetFileClient(Randomize("sample-file")); // Upload the file using (FileStream stream = File.OpenRead(originalPath)) { await file.CreateAsync(stream.Length); await file.UploadRangeAsync( FileRangeWriteType.Update, new HttpRange(0, stream.Length), stream); } // Download the file StorageFileDownloadInfo download = await file.DownloadAsync(); using (FileStream stream = File.OpenWrite(downloadPath)) { await download.Content.CopyToAsync(stream); } // Verify the contents Assert.AreEqual(SampleFileContent, File.ReadAllText(downloadPath)); } finally { // Clean up after the test when we're finished await share.DeleteAsync(); } }
public IActionResult UploadAzure() { try { var file = Request.Form.Files[0]; var folderName = Path.Combine("StaticFiles", "Images"); var pathToSave = Path.Combine(Directory.GetCurrentDirectory(), folderName); if (file.Length > 0) { var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"'); var fullPath = Path.Combine(pathToSave, fileName); var dbPath = Path.Combine(folderName, fileName); using (var stream = new FileStream(fullPath, FileMode.Create)) { file.CopyTo(stream); } // Get a reference to a share and then create it ShareClient share = new ShareClient("DefaultEndpointsProtocol=https;AccountName=faceidentity;AccountKey=N/gO9IA0exmgv4yH+ZISlxc0wxv2haDMWi2fZoL2/ErfqM/KHAePM4qkwMjnWEXesDvDidDVYJqKAtv3FvaXnQ==;EndpointSuffix=core.windows.net", "employeesimages"); // share.Create(); // Get a reference to a directory and create it ShareDirectoryClient directory = share.GetDirectoryClient("auth"); // directory.Create(); // Get a reference to a file and upload it ShareFileClient fileAzure = directory.GetFileClient(fileName); using (FileStream stream = System.IO.File.OpenRead(fullPath)) { fileAzure.Create(stream.Length); fileAzure.UploadRange( new HttpRange(0, stream.Length), stream); } string fileAzurePath = fileAzure.Uri.ToString(); //System.IO.File.Delete(fullPath); return(Ok(new { fileAzurePath })); } else { return(BadRequest()); } } catch (Exception ex) { return(StatusCode(500, $"Internal server error: {ex}")); } }
public async Task Capture_Span_When_Create_File_Share() { var shareName = Guid.NewGuid().ToString(); var client = new ShareClient(_environment.StorageAccountConnectionString, shareName); await _agent.Tracer.CaptureTransaction("Create Azure File Share", ApiConstants.TypeStorage, async() => { var response = await client.CreateAsync(); }); AssertSpan("Create", shareName); }
/// <summary> /// Updates the remote project's schema and restarts the service /// </summary> /// <param name="project"></param> /// <param name="schemaPath"></param> /// <returns></returns> public async Task UpdateSchema(RemoteProject project, string schemaPath) { await InitClient(); SchemaValidator.ValidateSchema(schemaPath); var shareClient = new ShareClient(project.StorageConnectionString, project.AzureFileShare); await UploadSchema(shareClient, schemaPath, RemoteCsdlFileDir, RemoteCsdlFileName); await azure.ContainerGroups.GetByResourceGroup(project.ResourceGroup, project.AppId).RestartAsync(); project.LocalSchemaPath = schemaPath; }
public async Task UploadAsync() { // Create a temporary Lorem Ipsum file on disk that we can upload string path = CreateTempFile(SampleFileContent); // Get a connection string to our Azure Storage account. You can // obtain your connection string from the Azure Portal (click // Access Keys under Settings in the Portal Storage account blade) // or using the Azure CLI with: // // az storage account show-connection-string --name <account_name> --resource-group <resource_group> // // And you can provide the connection string to your application // using an environment variable. string connectionString = ConnectionString; // Get a reference to a share named "sample-share" and then create it ShareClient share = new ShareClient(connectionString, Randomize("sample-share")); await share.CreateAsync(); try { // Get a reference to a directory named "sample-dir" and then create it DirectoryClient directory = share.GetDirectoryClient(Randomize("sample-dir")); await directory.CreateAsync(); // Get a reference to a file named "sample-file" in directory "sample-dir" FileClient file = directory.GetFileClient(Randomize("sample-file")); // Upload the file using (FileStream stream = File.OpenRead(path)) { await file.CreateAsync(stream.Length); await file.UploadRangeAsync( FileRangeWriteType.Update, new HttpRange(0, stream.Length), stream); } // Verify the file exists StorageFileProperties properties = await file.GetPropertiesAsync(); Assert.AreEqual(SampleFileContent.Length, properties.ContentLength); } finally { // Clean up after the test when we're finished await share.DeleteAsync(); } }
public async Task Sample01b_HelloWorldAsync_TraverseAsync() { // Create a temporary Lorem Ipsum file on disk that we can upload string originalPath = CreateTempFile(SampleFileContent); // Get a reference to a share named "sample-share" and then create it string shareName = Randomize("sample-share"); ShareClient share = new ShareClient(ConnectionString, shareName); await share.CreateAsync(); try { // Create a bunch of directories ShareDirectoryClient first = await share.CreateDirectoryAsync("first"); await first.CreateSubdirectoryAsync("a"); await first.CreateSubdirectoryAsync("b"); ShareDirectoryClient second = await share.CreateDirectoryAsync("second"); await second.CreateSubdirectoryAsync("c"); await second.CreateSubdirectoryAsync("d"); await share.CreateDirectoryAsync("third"); ShareDirectoryClient fourth = await share.CreateDirectoryAsync("fourth"); ShareDirectoryClient deepest = await fourth.CreateSubdirectoryAsync("e"); // Upload a file named "file" ShareFileClient file = deepest.GetFileClient("file"); using (FileStream stream = File.OpenRead(originalPath)) { await file.CreateAsync(stream.Length); await file.UploadRangeAsync( ShareFileRangeWriteType.Update, new HttpRange(0, stream.Length), stream); } await Sample01b_HelloWorldAsync.TraverseAsync(ConnectionString, shareName); } finally { await share.DeleteAsync(); } }
/// <summary> /// Manage share properties /// </summary> /// <param name="shareServiceClient"></param> /// <returns></returns> private static async Task SharePropertiesSample(ShareServiceClient shareServiceClient) { Console.WriteLine(); // Create the share name -- use a guid in the name so it's unique. string shareName = "demotest-" + Guid.NewGuid(); ShareClient shareClient = shareServiceClient.GetShareClient(shareName); try { // Create Share Console.WriteLine("Create Share"); await shareClient.CreateIfNotExistsAsync(); // Set share properties Console.WriteLine("Set share properties"); await shareClient.SetQuotaAsync(100); // Fetch share properties ShareProperties shareProperties = await shareClient.GetPropertiesAsync(); Console.WriteLine("Get share properties:"); Console.WriteLine(" Quota: {0}", shareProperties.QuotaInGB); Console.WriteLine(" ETag: {0}", shareProperties.ETag); Console.WriteLine(" Last modified: {0}", shareProperties.LastModified); } catch (RequestFailedException exRequest) { Common.WriteException(exRequest); Console.WriteLine( "Please make sure your storage account is specified correctly in the app.config - then restart the sample."); Console.WriteLine("Press any key to exit"); Console.ReadLine(); throw; } catch (Exception ex) { Console.WriteLine(" Exception thrown creating share."); Common.WriteException(ex); throw; } finally { // Delete share Console.WriteLine("Delete share"); await shareClient.DeleteIfExistsAsync(); } Console.WriteLine(); }
public IActionResult Post(string userId) { try { IFormFileCollection files = Request.Form.Files; if (files.Count == 0) { return(BadRequest()); } // Get a reference to a share and then create it ShareClient share = new ShareClient(Secret.AzureConnectionString, Secret.AzureFileShareName); if (!share.Exists()) { share.Create(); } // Get a reference to a directory and create it ShareDirectoryClient directory = share.GetDirectoryClient(Auth0Utils.GetUserFolder()); if (!directory.Exists()) { directory.Create(); } // Get a reference to a file and upload it ShareFileClient fileClient; foreach (IFormFile file in files) { fileClient = directory.GetFileClient(file.FileName); fileClient.DeleteIfExists(); using (Stream stream = file.OpenReadStream()) { fileClient.Create(stream.Length); fileClient.UploadRange( new HttpRange(0, stream.Length), stream); } } return(Ok()); } catch (Exception e) { return(StatusCode(500, e.Message)); } }
public async Task Setup() { SharedSetup(); _directoryMock = new Mock <ShareDirectoryClient>(); _input = new Mock <IPathFilter>(); ShareClient.Setup(s => s.GetRootDirectoryClient()) .Returns(_directoryMock.Object); _directories = new[] { new [] { FilesModelFactory.StorageFileItem(true, "Recurse1", 0) }, new [] { FilesModelFactory.StorageFileItem(true, "Recurse2", 0) }, new [] { FilesModelFactory.StorageFileItem(true, "Recurse3", 0) }, new [] { FilesModelFactory.StorageFileItem(true, "Recurse4", 0) }, new [] { FilesModelFactory.StorageFileItem(true, "Recurse5", 0) }, new [] { FilesModelFactory.StorageFileItem(true, "Collect1", 0), FilesModelFactory.StorageFileItem(true, "Collect2", 0) } }; var pathActionSequence = _input.SetupSequence(s => s.DecideAction(It.IsAny <string>())); var directoryContentsSequence = _directoryMock.SetupSequence(s => s.GetFilesAndDirectoriesAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())); var pathSequence = _directoryMock.SetupSequence(s => s.Path); _directoryMock.Setup(s => s.GetSubdirectoryClient(It.IsAny <string>())).Returns(() => _directoryMock.Object); for (var i = 0; i < NumberOfDirectoriesInTree; i++) { var item = _directories[i]; directoryContentsSequence.Returns(() => MockPageable(item).Object); pathActionSequence.Returns(PathAction.Recurse); pathSequence.Returns(string.Join("/", _directories.SelectMany(s => s.Select(x => x.Name)).Take(i))); } pathSequence.Returns(string.Join("/", _directories.SelectMany(s => s.Select(x => x.Name)).Take(5))); for (var i = NumberOfDirectoriesInTree; i < _directories.Length; i++) { var items = _directories[i]; directoryContentsSequence.Returns(() => MockPageable(items).Object); foreach (var subItem in items) { pathActionSequence.Returns(PathAction.Collect); } } _output = await ClassInTest.ListAsync(_input.Object, CancellationToken.None).AsEnumerableAsync(); }
/// <summary> /// Trigger a recoverable error. /// </summary> /// <param name="connectionString"> /// A connection string to your Azure Storage account. /// </param> /// <param name="shareName"> /// The name of an existing share /// </param> public static async Task ErrorsAsync(string connectionString, string shareName) { ShareClient share = new ShareClient(connectionString, shareName); try { // Try to create the share again await share.CreateAsync(); } catch (RequestFailedException ex) when(ex.ErrorCode == ShareErrorCode.ShareAlreadyExists) { // Ignore any errors if the share already exists } }