public StandaloneAzureBlobContainerListTests()
            : base(DirectoryType.Container)
        {
            _container = new StandaloneAzureBlobContainer(BasePath);
            _container.CreateIfNotExists(BlobContainerPublicAccessType.Off);

            Directory.CreateDirectory(Path.Combine(BasePath, "1a"));
            Directory.CreateDirectory(Path.Combine(BasePath, "1b"));
            Directory.CreateDirectory(Path.Combine(BasePath, "1c"));
            Directory.CreateDirectory(Path.Combine(BasePath, "1d"));
            Directory.CreateDirectory(Path.Combine(BasePath, "1e"));
            Directory.CreateDirectory(Path.Combine(BasePath, "2a"));
            Directory.CreateDirectory(Path.Combine(BasePath, "2b"));
            Directory.CreateDirectory(Path.Combine(BasePath, "2c"));
            Directory.CreateDirectory(Path.Combine(BasePath, "2d"));
            Directory.CreateDirectory(Path.Combine(BasePath, "2e"));

            File.WriteAllText(Path.Combine(BasePath, "1"), "Test File");
            File.WriteAllText(Path.Combine(BasePath, "2"), "Test File");
            File.WriteAllText(Path.Combine(BasePath, "3"), "Test File");
            File.WriteAllText(Path.Combine(BasePath, "4"), "Test File");
            File.WriteAllText(Path.Combine(BasePath, "5"), "Test File");

            File.WriteAllText(Path.Combine(BasePath, "1a", "1"), "Test File");
            File.WriteAllText(Path.Combine(BasePath, "1a", "2"), "Test File");
            File.WriteAllText(Path.Combine(BasePath, "1a", "3"), "Test File");
            File.WriteAllText(Path.Combine(BasePath, "1a", "4"), "Test File");
            File.WriteAllText(Path.Combine(BasePath, "1a", "5"), "Test File");
        }
 public void AllowsSnapshotsOnlyInFlatMode(BlobListingDetails blobListingDetails)
 {
     var container = new StandaloneAzureBlobContainer(BasePath);
     Assert.Throws<ArgumentException>(() => container.ListBlobsSegmentedAsync(
         "",
         BlobListing.Hierarchical,
         blobListingDetails,
         500,
         null));
 }
        public void CanDetermineContainerDoesNotExist()
        {
            var container = new StandaloneAzureBlobContainer(_containerPath);

            Assert.False(container.Exists());
        }
        public void CanDetermineContainerExists()
        {
            var container = new StandaloneAzureBlobContainer(_containerPath);

            container.CreateIfNotExists(BlobContainerPublicAccessType.Off);

            Assert.True(container.Exists());
        }
        public void WillHaveCorrectUriWhenGivenBasePathAndContainerName()
        {
            var container = new StandaloneAzureBlobContainer(BasePath, ContainerName);

            Assert.Equal(new Uri(_containerPath), container.Uri);
        }
        public void WillHaveCorrectUriWhenGivenUri()
        {
            var container = new StandaloneAzureBlobContainer(new Uri(_containerPath));

            Assert.Equal(new Uri(_containerPath), container.Uri);
        }
        public void CanGetBlobInstance()
        {
            var container = new StandaloneAzureBlobContainer(_containerPath);
            container.CreateIfNotExists(BlobContainerPublicAccessType.Off);

            var blob = container.GetBlockBlobReference("testblob");

            new
            {
                Name = "testblob",
                Uri = new Uri(Path.Combine(_containerPath, "testblob"))
            }.ToExpectedObject().ShouldMatch(blob);
        }
        public void WillReturnEmptyStringForSharedAccessKeySignature(SharedAccessBlobPermissions permissions)
        {
            var container = new StandaloneAzureBlobContainer(new Uri(_containerPath));

            Assert.Equal("", container.GetSharedAccessSignature(new SharedAccessBlobPolicy
            {
                Permissions = permissions
            }));
        }
        public async Task CanDetermineContainerExistsAsync()
        {
            var container = new StandaloneAzureBlobContainer(_containerPath);

            container.CreateIfNotExists(BlobContainerPublicAccessType.Off);

            Assert.True(await container.ExistsAsynx());
        }
        public async Task CanDetermineContainerDoesNotExistAsync()
        {
            var container = new StandaloneAzureBlobContainer(_containerPath);

            Assert.False(await container.ExistsAsynx());
        }
        public void WillReturnParseableSharedAccessSignature(
            SharedAccessBlobPermissions permissions, 
            string expectedPermissions)
        {
            var container = new StandaloneAzureBlobContainer(new Uri(_containerPath));

            Assert.Contains(expectedPermissions, container.GetSharedAccessSignature(new SharedAccessBlobPolicy
            {
                Permissions = permissions
            }));
        }
        public void WillThrowIfBlobNameEmpty()
        {
            var container = new StandaloneAzureBlobContainer(_containerPath);

            Assert.Throws<ArgumentException>(() => container.GetBlockBlobReference(""));
        }
        public void WillThrowIfBlobNameNotGiven()
        {
            var container = new StandaloneAzureBlobContainer(_containerPath);

            Assert.Throws<ArgumentNullException>(() => container.GetBlockBlobReference(null));
        }