class StorageContainerTestAsync(StorageTestCase):
def setUp(self):
super(StorageContainerTestAsync, self).setUp()
url = self._get_account_url()
credential = self._get_shared_key_credential()
self.bsc = BlobServiceClient(url,
credential=credential,
transport=AiohttpTestTransport())
loop = asyncio.get_event_loop()
loop.run_until_complete(self.bsc.__aenter__())
self.test_containers = []
def tearDown(self):
if not self.is_playback():
loop = asyncio.get_event_loop()
for container_name in self.test_containers:
try:
container = self.bsc.get_container_client(container_name)
loop.run_until_complete(container.delete_container())
except HttpResponseError:
try:
lease = LeaseClient(container)
loop.run_until_complete(lease.break_lease(0))
loop.run_until_complete(container.delete_container())
except:
pass
except:
pass
loop.run_until_complete(self.bsc.__aexit__())
return super(StorageContainerTestAsync, self).tearDown()
#--Helpers-----------------------------------------------------------------
def _get_container_reference(self, prefix=TEST_CONTAINER_PREFIX):
container_name = self.get_resource_name(prefix)
self.test_containers.append(container_name)
return container_name
async def _create_container(self, prefix=TEST_CONTAINER_PREFIX):
container_name = self._get_container_reference(prefix)
container = self.bsc.get_container_client(container_name)
try:
await container.create_container()
except ResourceExistsError:
pass
return container
#--Test cases for containers -----------------------------------------
async def _test_create_container(self):
# Arrange
container_name = self._get_container_reference()
# Act
container = self.bsc.get_container_client(container_name)
created = await container.create_container()
# Assert
self.assertTrue(created)
@record
def test_create_container(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_create_container())
async def _test_create_container_with_already_existing_container_fail_on_exist(
self):
# Arrange
container_name = self._get_container_reference()
# Act
container = self.bsc.get_container_client(container_name)
created = await container.create_container()
with self.assertRaises(HttpResponseError):
await container.create_container()
# Assert
self.assertTrue(created)
@record
def test_create_container_with_already_existing_container_fail_on_exist(
self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self.
_test_create_container_with_already_existing_container_fail_on_exist(
))
async def _test_create_container_with_public_access_container(self):
# Arrange
container_name = self._get_container_reference()
# Act
container = self.bsc.get_container_client(container_name)
created = await container.create_container(public_access='container')
# Assert
self.assertTrue(created)
@record
def test_create_container_with_public_access_container(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_create_container_with_public_access_container())
async def _test_create_container_with_public_access_blob(self):
# Arrange
container_name = self._get_container_reference()
# Act
container = self.bsc.get_container_client(container_name)
created = await container.create_container(public_access='blob')
blob = container.get_blob_client("blob1")
await blob.upload_blob(u'xyz')
anonymous_service = BlobClient(self._get_account_url(),
container=container_name,
blob="blob1")
# Assert
self.assertTrue(created)
await anonymous_service.download_blob()
@record
def test_create_container_with_public_access_blob(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_create_container_with_public_access_blob())
async def _test_create_container_with_metadata(self):
# Arrange
container_name = self._get_container_reference()
metadata = {'hello': 'world', 'number': '42'}
# Act
container = self.bsc.get_container_client(container_name)
created = await container.create_container(metadata)
# Assert
self.assertTrue(created)
md_cr = await container.get_container_properties()
md = md_cr.metadata
self.assertDictEqual(md, metadata)
@record
def test_create_container_with_metadata(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_create_container_with_metadata())
async def _test_container_exists_with_lease(self):
# Arrange
container = await self._create_container()
await container.acquire_lease()
# Act
exists = await container.get_container_properties()
# Assert
self.assertTrue(exists)
@record
def test_container_exists_with_lease(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_container_exists_with_lease())
async def _test_unicode_create_container_unicode_name(self):
# Arrange
container_name = u'啊齄丂狛狜'
container = self.bsc.get_container_client(container_name)
# Act
with self.assertRaises(HttpResponseError):
# not supported - container name must be alphanumeric, lowercase
await container.create_container()
# Assert
@record
def test_unicode_create_container_unicode_name(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_unicode_create_container_unicode_name())
async def _test_list_containers(self):
# Arrange
container = await self._create_container()
# Act
containers = []
async for c in self.bsc.list_containers():
containers.append(c)
# Assert
self.assertIsNotNone(containers)
self.assertGreaterEqual(len(containers), 1)
self.assertIsNotNone(containers[0])
self.assertNamedItemInContainer(containers, container.container_name)
self.assertIsNotNone(containers[0].has_immutability_policy)
self.assertIsNotNone(containers[0].has_legal_hold)
@record
def test_list_containers(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_containers())
async def _test_list_containers_with_prefix(self):
# Arrange
container = await self._create_container()
# Act
containers = []
async for c in self.bsc.list_containers(
name_starts_with=container.container_name):
containers.append(c)
# Assert
self.assertIsNotNone(containers)
self.assertEqual(len(containers), 1)
self.assertIsNotNone(containers[0])
self.assertEqual(containers[0].name, container.container_name)
self.assertIsNone(containers[0].metadata)
@record
def test_list_containers_with_prefix(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_containers_with_prefix())
async def _test_list_containers_with_include_metadata(self):
# Arrange
container = await self._create_container()
metadata = {'hello': 'world', 'number': '42'}
resp = await container.set_container_metadata(metadata)
# Act
containers = []
async for c in self.bsc.list_containers(
name_starts_with=container.container_name,
include_metadata=True):
containers.append(c)
# Assert
self.assertIsNotNone(containers)
self.assertGreaterEqual(len(containers), 1)
self.assertIsNotNone(containers[0])
self.assertNamedItemInContainer(containers, container.container_name)
self.assertDictEqual(containers[0].metadata, metadata)
@record
def test_list_containers_with_include_metadata(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_list_containers_with_include_metadata())
async def _test_list_containers_with_public_access(self):
# Arrange
container = await self._create_container()
resp = await container.set_container_access_policy(
public_access=PublicAccess.Blob)
# Act
containers = []
async for c in self.bsc.list_containers(
name_starts_with=container.container_name):
containers.append(c)
# Assert
self.assertIsNotNone(containers)
self.assertGreaterEqual(len(containers), 1)
self.assertIsNotNone(containers[0])
self.assertNamedItemInContainer(containers, container.container_name)
self.assertEqual(containers[0].public_access, PublicAccess.Blob)
@record
def test_list_containers_with_public_access(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_list_containers_with_public_access())
async def _test_list_containers_with_num_results_and_marker(self):
# Arrange
prefix = 'listcontainer'
container_names = []
for i in range(0, 4):
cr = await self._create_container(prefix + str(i))
container_names.append(cr.container_name)
container_names.sort()
# Act
generator1 = self.bsc.list_containers(name_starts_with=prefix,
results_per_page=2).by_page()
containers1 = []
async for c in await generator1.__anext__():
containers1.append(c)
generator2 = self.bsc.list_containers(
name_starts_with=prefix,
results_per_page=2).by_page(generator1.continuation_token)
containers2 = []
async for c in await generator2.__anext__():
containers2.append(c)
# Assert
self.assertIsNotNone(containers1)
self.assertEqual(len(containers1), 2)
self.assertNamedItemInContainer(containers1, container_names[0])
self.assertNamedItemInContainer(containers1, container_names[1])
self.assertIsNotNone(containers2)
self.assertEqual(len(containers2), 2)
self.assertNamedItemInContainer(containers2, container_names[2])
self.assertNamedItemInContainer(containers2, container_names[3])
@record
def test_list_containers_with_num_results_and_marker(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_list_containers_with_num_results_and_marker())
async def _test_set_container_metadata(self):
# Arrange
metadata = {'hello': 'world', 'number': '43'}
container = await self._create_container()
# Act
await container.set_container_metadata(metadata)
md = await container.get_container_properties()
metadata_from_response = md.metadata
# Assert
self.assertDictEqual(metadata_from_response, metadata)
@record
def test_set_container_metadata(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_set_container_metadata())
async def _test_set_container_metadata_with_lease_id(self):
# Arrange
metadata = {'hello': 'world', 'number': '43'}
container = await self._create_container()
lease_id = await container.acquire_lease()
# Act
await container.set_container_metadata(metadata, lease_id)
# Assert
md = await container.get_container_properties()
md = md.metadata
self.assertDictEqual(md, metadata)
@record
def test_set_container_metadata_with_lease_id(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_set_container_metadata_with_lease_id())
async def _test_set_container_metadata_with_non_existing_container(self):
# Arrange
container_name = self._get_container_reference()
container = self.bsc.get_container_client(container_name)
# Act
with self.assertRaises(ResourceNotFoundError):
await container.set_container_metadata({
'hello': 'world',
'number': '43'
})
# Assert
@record
def test_set_container_metadata_with_non_existing_container(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_set_container_metadata_with_non_existing_container())
async def _test_get_container_metadata(self):
# Arrange
metadata = {'hello': 'world', 'number': '42'}
container = await self._create_container()
await container.set_container_metadata(metadata)
# Act
md_cr = await container.get_container_properties()
md = md_cr.metadata
# Assert
self.assertDictEqual(md, metadata)
@record
def test_get_container_metadata(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_get_container_metadata())
async def _test_get_container_metadata_with_lease_id(self):
# Arrange
metadata = {'hello': 'world', 'number': '42'}
container = await self._create_container()
await container.set_container_metadata(metadata)
lease_id = await container.acquire_lease()
# Act
md = await container.get_container_properties(lease_id)
md = md.metadata
# Assert
self.assertDictEqual(md, metadata)
@record
def test_get_container_metadata_with_lease_id(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_get_container_metadata_with_lease_id())
async def _test_get_container_properties(self):
# Arrange
metadata = {'hello': 'world', 'number': '42'}
container = await self._create_container()
await container.set_container_metadata(metadata)
# Act
props = await container.get_container_properties()
# Assert
self.assertIsNotNone(props)
self.assertDictEqual(props.metadata, metadata)
# self.assertEqual(props.lease.duration, 'infinite')
# self.assertEqual(props.lease.state, 'leased')
# self.assertEqual(props.lease.status, 'locked')
# self.assertEqual(props.public_access, 'container')
self.assertIsNotNone(props.has_immutability_policy)
self.assertIsNotNone(props.has_legal_hold)
@record
def test_get_container_properties(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_get_container_properties())
async def _test_get_container_properties_with_lease_id(self):
# Arrange
metadata = {'hello': 'world', 'number': '42'}
container = await self._create_container()
await container.set_container_metadata(metadata)
lease_id = await container.acquire_lease()
# Act
props = await container.get_container_properties(lease_id)
await lease_id.break_lease()
# Assert
self.assertIsNotNone(props)
self.assertDictEqual(props.metadata, metadata)
self.assertEqual(props.lease.duration, 'infinite')
self.assertEqual(props.lease.state, 'leased')
self.assertEqual(props.lease.status, 'locked')
@record
def test_get_container_properties_with_lease_id(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_get_container_properties_with_lease_id())
async def _test_get_container_acl(self):
# Arrange
container = await self._create_container()
# Act
acl = await container.get_container_access_policy()
# Assert
self.assertIsNotNone(acl)
self.assertIsNone(acl.get('public_access'))
self.assertEqual(len(acl.get('signed_identifiers')), 0)
@record
def test_get_container_acl(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_get_container_acl())
async def _test_get_container_acl_with_lease_id(self):
# Arrange
container = await self._create_container()
lease_id = await container.acquire_lease()
# Act
acl = await container.get_container_access_policy(lease_id)
# Assert
self.assertIsNotNone(acl)
self.assertIsNone(acl.get('public_access'))
@record
def test_get_container_acl_with_lease_id(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_get_container_acl_with_lease_id())
async def _test_set_container_acl(self):
# Arrange
container = await self._create_container()
# Act
response = await container.set_container_access_policy()
self.assertIsNotNone(response.get('etag'))
self.assertIsNotNone(response.get('last_modified'))
# Assert
acl = await container.get_container_access_policy()
self.assertIsNotNone(acl)
self.assertEqual(len(acl.get('signed_identifiers')), 0)
self.assertIsNone(acl.get('public_access'))
@record
def test_set_container_acl(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_set_container_acl())
async def _test_set_container_acl_with_one_signed_identifier(self):
# Arrange
from dateutil.tz import tzutc
container = await self._create_container()
# Act
access_policy = AccessPolicy(permission=ContainerPermissions.READ,
expiry=datetime.utcnow() +
timedelta(hours=1),
start=datetime.utcnow())
signed_identifier = {'testid': access_policy}
response = await container.set_container_access_policy(
signed_identifier)
# Assert
self.assertIsNotNone(response.get('etag'))
self.assertIsNotNone(response.get('last_modified'))
@record
def test_set_container_acl_with_one_signed_identifier(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_set_container_acl_with_one_signed_identifier())
async def _test_set_container_acl_with_lease_id(self):
# Arrange
container = await self._create_container()
lease_id = await container.acquire_lease()
# Act
await container.set_container_access_policy(lease=lease_id)
# Assert
acl = await container.get_container_access_policy()
self.assertIsNotNone(acl)
self.assertIsNone(acl.get('public_access'))
@record
def test_set_container_acl_with_lease_id(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_set_container_acl_with_lease_id())
async def _test_set_container_acl_with_public_access(self):
# Arrange
container = await self._create_container()
# Act
await container.set_container_access_policy(public_access='container')
# Assert
acl = await container.get_container_access_policy()
self.assertIsNotNone(acl)
self.assertEqual('container', acl.get('public_access'))
@record
def test_set_container_acl_with_public_access(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_set_container_acl_with_public_access())
async def _test_set_container_acl_with_empty_signed_identifiers(self):
# Arrange
container = await self._create_container()
# Act
await container.set_container_access_policy(signed_identifiers=dict())
# Assert
acl = await container.get_container_access_policy()
self.assertIsNotNone(acl)
self.assertEqual(len(acl.get('signed_identifiers')), 0)
self.assertIsNone(acl.get('public_access'))
@record
def test_set_container_acl_with_empty_signed_identifiers(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_set_container_acl_with_empty_signed_identifiers())
async def _test_set_container_acl_with_signed_identifiers(self):
# Arrange
container = await self._create_container()
# Act
access_policy = AccessPolicy(
permission=ContainerPermissions.READ,
expiry=datetime.utcnow() + timedelta(hours=1),
start=datetime.utcnow() - timedelta(minutes=1))
identifiers = {'testid': access_policy}
await container.set_container_access_policy(identifiers)
# Assert
acl = await container.get_container_access_policy()
self.assertIsNotNone(acl)
self.assertEqual('testid', acl.get('signed_identifiers')[0].id)
self.assertIsNone(acl.get('public_access'))
@record
def test_set_container_acl_with_signed_identifiers(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_set_container_acl_with_signed_identifiers())
async def _test_set_container_acl_with_empty_identifiers(self):
# Arrange
container = await self._create_container()
identifiers = {i: None for i in range(0, 3)}
# Act
await container.set_container_access_policy(identifiers)
# Assert
acl = await container.get_container_access_policy()
self.assertIsNotNone(acl)
self.assertEqual(len(acl.get('signed_identifiers')), 3)
self.assertEqual('0', acl.get('signed_identifiers')[0].id)
self.assertIsNone(acl.get('signed_identifiers')[0].access_policy)
self.assertIsNone(acl.get('public_access'))
@record
def test_set_container_acl_with_empty_identifiers(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_set_container_acl_with_empty_identifiers())
async def _test_set_container_acl_with_three_identifiers(self):
# Arrange
container = await self._create_container()
access_policy = AccessPolicy(
permission=ContainerPermissions.READ,
expiry=datetime.utcnow() + timedelta(hours=1),
start=datetime.utcnow() - timedelta(minutes=1))
identifiers = {i: access_policy for i in range(2)}
# Act
await container.set_container_access_policy(identifiers)
# Assert
acl = await container.get_container_access_policy()
self.assertIsNotNone(acl)
self.assertEqual(len(acl.get('signed_identifiers')), 2)
self.assertEqual('0', acl.get('signed_identifiers')[0].id)
self.assertIsNotNone(acl.get('signed_identifiers')[0].access_policy)
self.assertIsNone(acl.get('public_access'))
@record
def test_set_container_acl_with_three_identifiers(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_set_container_acl_with_three_identifiers())
async def _test_set_container_acl_too_many_ids(self):
# Arrange
container_name = await self._create_container()
# Act
identifiers = dict()
for i in range(0, 6):
identifiers['id{}'.format(i)] = AccessPolicy()
# Assert
with self.assertRaises(ValueError) as e:
await container_name.set_container_access_policy(identifiers)
self.assertEqual(
str(e.exception),
'Too many access policies provided. The server does not support setting more than 5 access policies on a single resource.'
)
@record
def test_set_container_acl_too_many_ids(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_set_container_acl_too_many_ids())
async def _test_lease_container_acquire_and_release(self):
# Arrange
container = await self._create_container()
# Act
lease = await container.acquire_lease()
await lease.release()
# Assert
@record
def test_lease_container_acquire_and_release(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_lease_container_acquire_and_release())
async def _test_lease_container_renew(self):
# Arrange
container = await self._create_container()
lease = await container.acquire_lease(lease_duration=15)
self.sleep(10)
lease_id_start = lease.id
# Act
await lease.renew()
# Assert
self.assertEqual(lease.id, lease_id_start)
self.sleep(5)
with self.assertRaises(HttpResponseError):
await container.delete_container()
self.sleep(10)
await container.delete_container()
@record
def test_lease_container_renew(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_lease_container_renew())
async def _test_lease_container_break_period(self):
# Arrange
container = await self._create_container()
# Act
lease = await container.acquire_lease(lease_duration=15)
# Assert
await lease.break_lease(lease_break_period=5)
self.sleep(6)
with self.assertRaises(HttpResponseError):
await container.delete_container(lease=lease)
@record
def test_lease_container_break_period(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_lease_container_break_period())
async def _test_lease_container_break_released_lease_fails(self):
# Arrange
container = await self._create_container()
lease = await container.acquire_lease()
await lease.release()
# Act
with self.assertRaises(HttpResponseError):
await lease.break_lease()
# Assert
@record
def test_lease_container_break_released_lease_fails(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_lease_container_break_released_lease_fails())
async def _test_lease_container_with_duration(self):
# Arrange
container = await self._create_container()
# Act
lease = await container.acquire_lease(lease_duration=15)
# Assert
with self.assertRaises(HttpResponseError):
await container.acquire_lease()
self.sleep(15)
await container.acquire_lease()
@record
def test_lease_container_with_duration(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_lease_container_with_duration())
async def _test_lease_container_twice(self):
# Arrange
container = await self._create_container()
# Act
lease = await container.acquire_lease(lease_duration=15)
# Assert
lease2 = await container.acquire_lease(lease_id=lease.id)
self.assertEqual(lease.id, lease2.id)
@record
def test_lease_container_twice(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_lease_container_twice())
async def _test_lease_container_with_proposed_lease_id(self):
# Arrange
container = await self._create_container()
# Act
proposed_lease_id = '55e97f64-73e8-4390-838d-d9e84a374321'
lease = await container.acquire_lease(lease_id=proposed_lease_id)
# Assert
self.assertEqual(proposed_lease_id, lease.id)
@record
def test_lease_container_with_proposed_lease_id(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_lease_container_with_proposed_lease_id())
async def _test_lease_container_change_lease_id(self):
# Arrange
container = await self._create_container()
# Act
lease_id = '29e0b239-ecda-4f69-bfa3-95f6af91464c'
lease = await container.acquire_lease()
lease_id1 = lease.id
await lease.change(proposed_lease_id=lease_id)
await lease.renew()
lease_id2 = lease.id
# Assert
self.assertIsNotNone(lease_id1)
self.assertIsNotNone(lease_id2)
self.assertNotEqual(lease_id1, lease_id)
self.assertEqual(lease_id2, lease_id)
@record
def test_lease_container_change_lease_id(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_lease_container_change_lease_id())
async def _test_delete_container_with_existing_container(self):
# Arrange
container = await self._create_container()
# Act
deleted = await container.delete_container()
# Assert
self.assertIsNone(deleted)
@record
def test_delete_container_with_existing_container(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_delete_container_with_existing_container())
async def _test_delete_container_with_non_existing_container_fail_not_exist(
self):
# Arrange
container_name = self._get_container_reference()
container = self.bsc.get_container_client(container_name)
# Act
with LogCaptured(self) as log_captured:
with self.assertRaises(ResourceNotFoundError):
await container.delete_container()
log_as_str = log_captured.getvalue()
#self.assertTrue('ERROR' in log_as_str)
@record
def test_delete_container_with_non_existing_container_fail_not_exist(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self.
_test_delete_container_with_non_existing_container_fail_not_exist(
))
async def _test_delete_container_with_lease_id(self):
# Arrange
container = await self._create_container()
lease = await container.acquire_lease(lease_duration=15)
# Act
deleted = await container.delete_container(lease=lease)
# Assert
self.assertIsNone(deleted)
with self.assertRaises(ResourceNotFoundError):
await container.get_container_properties()
@record
def test_delete_container_with_lease_id(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_delete_container_with_lease_id())
async def _test_list_names(self):
# Arrange
container = await self._create_container()
data = b'hello world'
await (container.get_blob_client('blob1')).upload_blob(data)
await (container.get_blob_client('blob2')).upload_blob(data)
# Act
blobs = []
async for b in container.list_blobs():
blobs.append(b.name)
self.assertEqual(blobs, ['blob1', 'blob2'])
@record
def test_list_names(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_names())
async def _test_list_blobs(self):
# Arrange
container = await self._create_container()
data = b'hello world'
cr0 = container.get_blob_client('blob1')
await cr0.upload_blob(data)
cr1 = container.get_blob_client('blob2')
await cr1.upload_blob(data)
# Act
blobs = []
async for b in container.list_blobs():
blobs.append(b)
# Assert
self.assertIsNotNone(blobs)
self.assertGreaterEqual(len(blobs), 2)
self.assertIsNotNone(blobs[0])
self.assertNamedItemInContainer(blobs, 'blob1')
self.assertNamedItemInContainer(blobs, 'blob2')
self.assertEqual(blobs[0].size, 11)
self.assertEqual(blobs[1].content_settings.content_type,
'application/octet-stream')
self.assertIsNotNone(blobs[0].creation_time)
@record
def test_list_blobs(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_blobs())
async def _test_list_blobs_leased_blob(self):
# Arrange
container = await self._create_container()
data = b'hello world'
blob1 = container.get_blob_client('blob1')
await blob1.upload_blob(data)
lease = await blob1.acquire_lease()
# Act
resp = []
async for b in container.list_blobs():
resp.append(b)
# Assert
self.assertIsNotNone(resp)
self.assertGreaterEqual(len(resp), 1)
self.assertIsNotNone(resp[0])
self.assertNamedItemInContainer(resp, 'blob1')
self.assertEqual(resp[0].size, 11)
self.assertEqual(resp[0].lease.duration, 'infinite')
self.assertEqual(resp[0].lease.status, 'locked')
self.assertEqual(resp[0].lease.state, 'leased')
@record
def test_list_blobs_leased_blob(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_blobs_leased_blob())
async def _test_list_blobs_with_prefix(self):
# Arrange
container = await self._create_container()
data = b'hello world'
c0 = container.get_blob_client('blob_a1')
await c0.upload_blob(data)
c1 = container.get_blob_client('blob_a2')
await c1.upload_blob(data)
c2 = container.get_blob_client('blob_b1')
await c2.upload_blob(data)
# Act
resp = []
async for b in container.list_blobs(name_starts_with='blob_a'):
resp.append(b)
# Assert
self.assertIsNotNone(resp)
self.assertEqual(len(resp), 2)
self.assertNamedItemInContainer(resp, 'blob_a1')
self.assertNamedItemInContainer(resp, 'blob_a2')
@record
def test_list_blobs_with_prefix(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_blobs_with_prefix())
async def _test_list_blobs_with_num_results(self):
# Arrange
container = await self._create_container()
data = b'hello world'
c0 = container.get_blob_client('blob_a1')
await c0.upload_blob(data)
c1 = container.get_blob_client('blob_a2')
await c1.upload_blob(data)
c2 = container.get_blob_client('blob_a3')
await c2.upload_blob(data)
c3 = container.get_blob_client('blob_b1')
await c3.upload_blob(data)
# Act
generator = container.list_blobs(results_per_page=2).by_page()
blobs = []
async for b in await generator.__anext__():
blobs.append(b)
# Assert
self.assertIsNotNone(blobs)
self.assertEqual(len(blobs), 2)
self.assertNamedItemInContainer(generator.current_page, 'blob_a1')
self.assertNamedItemInContainer(generator.current_page, 'blob_a2')
@record
def test_list_blobs_with_num_results(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_blobs_with_num_results())
async def _test_list_blobs_with_include_snapshots(self):
# Arrange
container = await self._create_container()
data = b'hello world'
blob1 = container.get_blob_client('blob1')
await blob1.upload_blob(data)
await blob1.create_snapshot()
await (container.get_blob_client('blob2')).upload_blob(data)
# Act
blobs = []
async for b in container.list_blobs(include="snapshots"):
blobs.append(b)
# Assert
self.assertEqual(len(blobs), 3)
self.assertEqual(blobs[0].name, 'blob1')
self.assertIsNotNone(blobs[0].snapshot)
self.assertEqual(blobs[1].name, 'blob1')
self.assertIsNone(blobs[1].snapshot)
self.assertEqual(blobs[2].name, 'blob2')
self.assertIsNone(blobs[2].snapshot)
@record
def test_list_blobs_with_include_snapshots(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_blobs_with_include_snapshots())
async def _test_list_blobs_with_include_metadata(self):
# Arrange
pytest.skip("Waiting on metadata XML fix in msrest")
container = await self._create_container()
data = b'hello world'
blob1 = container.get_blob_client('blob1')
await blob1.upload_blob(data, metadata={'number': '1', 'name': 'bob'})
await blob1.create_snapshot()
cr = container.get_blob_client('blob2')
await cr.upload_blob(data, metadata={'number': '2', 'name': 'car'})
# Act
blobs = []
async for b in container.list_blobs(include="metadata"):
blobs.append(b)
# Assert
self.assertEqual(len(blobs), 2)
self.assertEqual(blobs[0].name, 'blob1')
self.assertEqual(blobs[0].metadata['number'], '1')
self.assertEqual(blobs[0].metadata['name'], 'bob')
self.assertEqual(blobs[1].name, 'blob2')
self.assertEqual(blobs[1].metadata['number'], '2')
self.assertEqual(blobs[1].metadata['name'], 'car')
@record
def test_list_blobs_with_include_metadata(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_blobs_with_include_metadata())
async def _test_list_blobs_with_include_uncommittedblobs(self):
# Arrange
container = await self._create_container()
data = b'hello world'
blob1 = container.get_blob_client('blob1')
await blob1.stage_block('1', b'AAA')
await blob1.stage_block('2', b'BBB')
await blob1.stage_block('3', b'CCC')
blob2 = container.get_blob_client('blob2')
await blob2.upload_blob(data, metadata={'number': '2', 'name': 'car'})
# Act
blobs = []
async for b in container.list_blobs(include="uncommittedblobs"):
blobs.append(b)
# Assert
self.assertEqual(len(blobs), 2)
self.assertEqual(blobs[0].name, 'blob1')
self.assertEqual(blobs[1].name, 'blob2')
@record
def test_list_blobs_with_include_uncommittedblobs(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_list_blobs_with_include_uncommittedblobs())
async def _test_list_blobs_with_include_copy(self):
# Arrange
container = await self._create_container()
data = b'hello world'
await (container.get_blob_client('blob1')).upload_blob(
data, metadata={'status': 'original'})
sourceblob = 'https://{0}.blob.core.windows.net/{1}/blob1'.format(
self.settings.STORAGE_ACCOUNT_NAME, container.container_name)
blobcopy = container.get_blob_client('blob1copy')
await blobcopy.start_copy_from_url(sourceblob,
metadata={'status': 'copy'})
# Act
blobs = []
async for b in container.list_blobs(include="copy"):
blobs.append(b)
# Assert
self.assertEqual(len(blobs), 2)
self.assertEqual(blobs[0].name, 'blob1')
self.assertEqual(blobs[1].name, 'blob1copy')
self.assertEqual(blobs[1].blob_type, blobs[0].blob_type)
self.assertEqual(blobs[1].size, 11)
self.assertEqual(blobs[1].content_settings.content_type,
'application/octet-stream')
self.assertEqual(blobs[1].content_settings.cache_control, None)
self.assertEqual(blobs[1].content_settings.content_encoding, None)
self.assertEqual(blobs[1].content_settings.content_language, None)
self.assertEqual(blobs[1].content_settings.content_disposition, None)
self.assertNotEqual(blobs[1].content_settings.content_md5, None)
self.assertEqual(blobs[1].lease.status, 'unlocked')
self.assertEqual(blobs[1].lease.state, 'available')
self.assertNotEqual(blobs[1].copy.id, None)
self.assertEqual(blobs[1].copy.source, sourceblob)
self.assertEqual(blobs[1].copy.status, 'success')
self.assertEqual(blobs[1].copy.progress, '11/11')
self.assertNotEqual(blobs[1].copy.completion_time, None)
@record
def test_list_blobs_with_include_copy(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_blobs_with_include_copy())
async def _test_list_blobs_with_delimiter(self):
# Arrange
container = await self._create_container()
data = b'hello world'
cr0 = container.get_blob_client('a/blob1')
await cr0.upload_blob(data)
cr1 = container.get_blob_client('a/blob2')
await cr1.upload_blob(data)
cr2 = container.get_blob_client('b/blob3')
await cr2.upload_blob(data)
cr4 = container.get_blob_client('blob4')
await cr4.upload_blob(data)
# Act
resp = []
async for w in container.walk_blobs():
resp.append(w)
# Assert
self.assertIsNotNone(resp)
self.assertEqual(len(resp), 3)
self.assertNamedItemInContainer(resp, 'a/')
self.assertNamedItemInContainer(resp, 'b/')
self.assertNamedItemInContainer(resp, 'blob4')
@record
def test_list_blobs_with_delimiter(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_blobs_with_delimiter())
async def _test_walk_blobs_with_delimiter(self):
# Arrange
container = await self._create_container()
data = b'hello world'
cr0 = container.get_blob_client('a/blob1')
await cr0.upload_blob(data)
cr1 = container.get_blob_client('a/blob2')
await cr1.upload_blob(data)
cr2 = container.get_blob_client('b/c/blob3')
await cr2.upload_blob(data)
cr3 = container.get_blob_client('blob4')
await cr3.upload_blob(data)
blob_list = []
def recursive_walk(prefix):
for b in prefix:
if b.get('prefix'):
recursive_walk(b)
else:
blob_list.append(b.name)
# Act
recursive_walk(container.walk_blobs())
# Assert
self.assertEqual(len(blob_list), 4)
self.assertEqual(blob_list,
['a/blob1', 'a/blob2', 'b/c/blob3', 'blob4'])
@pytest.mark.skip
def test_walk_blobs_with_delimiter(self):
if TestMode.need_recording_file(self.test_mode):
return
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_walk_blobs_with_delimiter())
async def _test_list_blobs_with_include_multiple(self):
# Arrange
pytest.skip("Waiting on metadata XML fix in msrest")
container = await self._create_container()
data = b'hello world'
blob1 = container.get_blob_client('blob1')
await blob1.upload_blob(data, metadata={'number': '1', 'name': 'bob'})
await blob1.create_snapshot()
client = container.get_blob_client('blob2')
await client.upload_blob(data, metadata={'number': '2', 'name': 'car'})
# Act
blobs = []
async for b in container.list_blobs(include=["snapshots", "metadata"]):
blobs.append(b)
# Assert
self.assertEqual(len(blobs), 3)
self.assertEqual(blobs[0].name, 'blob1')
self.assertIsNotNone(blobs[0].snapshot)
self.assertEqual(blobs[0].metadata['number'], '1')
self.assertEqual(blobs[0].metadata['name'], 'bob')
self.assertEqual(blobs[1].name, 'blob1')
self.assertIsNone(blobs[1].snapshot)
self.assertEqual(blobs[1].metadata['number'], '1')
self.assertEqual(blobs[1].metadata['name'], 'bob')
self.assertEqual(blobs[2].name, 'blob2')
self.assertIsNone(blobs[2].snapshot)
self.assertEqual(blobs[2].metadata['number'], '2')
self.assertEqual(blobs[2].metadata['name'], 'car')
@record
def test_list_blobs_with_include_multiple(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_list_blobs_with_include_multiple())
async def _test_shared_access_container(self):
# SAS URL is calculated from storage key, so this test runs live only
if TestMode.need_recording_file(self.test_mode):
return
# Arrange
container = await self._create_container()
blob_name = 'blob1'
data = b'hello world'
blob = container.get_blob_client(blob_name)
await blob.upload_blob(data)
token = container.generate_shared_access_signature(
expiry=datetime.utcnow() + timedelta(hours=1),
permission=ContainerPermissions.READ,
)
blob = BlobClient(blob.url, credential=token)
# Act
response = requests.get(blob.url)
# Assert
self.assertTrue(response.ok)
self.assertEqual(data, response.content)
@record
def test_shared_access_container(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(self._test_shared_access_container())
async def _test_web_container_normal_operations_working(self):
web_container = "web"
# create the web container in case it does not exist yet
container = self.bsc.get_container_client(web_container)
try:
try:
created = await container.create_container()
self.assertIsNotNone(created)
except ResourceExistsError:
pass
# test if web container exists
exist = await container.get_container_properties()
self.assertTrue(exist)
# create a blob
blob_name = self.get_resource_name("blob")
blob_content = self.get_random_text_data(1024)
blob = container.get_blob_client(blob_name)
await blob.upload_blob(blob_content)
# get a blob
blob_data = await (await blob.download_blob()).content_as_bytes()
self.assertIsNotNone(blob)
self.assertEqual(blob_data.decode('utf-8'), blob_content)
finally:
# delete container
await container.delete_container()
@record
def test_web_container_normal_operations_working(self):
loop = asyncio.get_event_loop()
loop.run_until_complete(
self._test_web_container_normal_operations_working())