def _setup(self, storage_account, storage_account_key): file_url = self.account_url(storage_account_name, "file") credentials = storage_account_key self.fsc = ShareServiceClient(account_url=file_url, credential=credentials, transport=AiohttpTestTransport()) self.test_shares = []
def setUp(self): super(StorageDirectoryTest, self).setUp() url = self.get_file_url() credential = self.get_shared_key_credential() self.fsc = ShareServiceClient(url, credential=credential, transport=AiohttpTestTransport()) self.share_name = self.get_resource_name('utshare')
async def _setup(self, storage_account_name, storage_account_key): url = self.account_url(storage_account_name, "file") credential = storage_account_key self.fsc = ShareServiceClient(url, credential=credential, transport=AiohttpTestTransport()) self.share_name = self.get_resource_name('utshare') if not self.is_playback(): try: await self.fsc.create_share(self.share_name) except: pass
def setUp(self): super(StorageShareTest, self).setUp() file_url = self.get_file_url() credentials = self.get_shared_key_credential() self.fsc = ShareServiceClient(account_url=file_url, credential=credentials, transport=AiohttpTestTransport()) loop = asyncio.get_event_loop() loop.run_until_complete(self.fsc.__aenter__()) self.test_shares = []
def test_invalid_api_version(self): with pytest.raises(ValueError) as error: ShareServiceClient("https://foo.file.core.windows.net/account", credential="fake_key", api_version="foo") self.assertTrue( str(error.value).startswith("Unsupported API version 'foo'.")) with pytest.raises(ValueError) as error: ShareClient("https://foo.file.core.windows.net/account", "share_name", credential="fake_key", api_version="foo") self.assertTrue( str(error.value).startswith("Unsupported API version 'foo'.")) with pytest.raises(ValueError) as error: ShareDirectoryClient("https://foo.file.core.windows.net/account", "share_name", "dir_path", credential="fake_key", api_version="foo") self.assertTrue( str(error.value).startswith("Unsupported API version 'foo'.")) with pytest.raises(ValueError) as error: ShareFileClient("https://foo.file.core.windows.net/account", "share", self._get_file_reference(), credential="fake_key", api_version="foo") self.assertTrue( str(error.value).startswith("Unsupported API version 'foo'."))
async def list_shares_in_service_async(self): # Instantiate the ShareServiceClient from a connection string from azure.storage.fileshare.aio import ShareServiceClient file_service = ShareServiceClient.from_connection_string( self.connection_string) async with file_service: # [START fsc_create_shares] await file_service.create_share(share_name="fileshare1") # [END fsc_create_shares] try: # [START fsc_list_shares] # List the shares in the file service my_shares = [] async for s in file_service.list_shares(): my_shares.append(s) # Print the shares for share in my_shares: print(share) # [END fsc_list_shares] finally: # [START fsc_delete_shares] await file_service.delete_share(share_name="fileshare1")
async def _test_user_agent_custom_async(self): custom_app = "TestApp/v1.0" service = ShareServiceClient(self.get_file_url(), credential=self.account_key, user_agent=custom_app, transport=AiohttpTestTransport()) def callback1(response): self.assertTrue('User-Agent' in response.http_request.headers) self.assertEqual( response.http_request.headers['User-Agent'], "TestApp/v1.0 azsdk-python-storage-file-share/{} Python/{} ({})" .format(VERSION, platform.python_version(), platform.platform())) await service.get_service_properties(raw_response_hook=callback1) def callback2(response): self.assertTrue('User-Agent' in response.http_request.headers) self.assertEqual( response.http_request.headers['User-Agent'], "TestApp/v2.0 azsdk-python-storage-file-share/{} Python/{} ({})" .format(VERSION, platform.python_version(), platform.platform())) await service.get_service_properties(raw_response_hook=callback2, user_agent="TestApp/v2.0")
async def get_share_client_async(self): # [START get_share_client] from azure.storage.fileshare.aio import ShareServiceClient file_service = ShareServiceClient.from_connection_string( self.connection_string) # Get a share client to interact with a specific share share = file_service.get_share_client("fileshare2")
def setUp(self): super(FileServicePropertiesTest, self).setUp() url = self.get_file_url() credential = self.get_shared_key_credential() self.fsc = ShareServiceClient(url, credential=credential, transport=AiohttpTestTransport())
async def test_user_agent_default_async(self, storage_account_name, storage_account_key): self._setup(storage_account_name, storage_account_key) service = ShareServiceClient(self.account_url(storage_account_name, "file"), credential=self.account_key, transport=AiohttpTestTransport()) def callback(response): self.assertTrue('User-Agent' in response.http_request.headers) assert "azsdk-python-storage-file-share/{}".format(VERSION) in response.http_request.headers['User-Agent'] await service.get_service_properties(raw_response_hook=callback)
async def test_user_agent_append_async(self, storage_account_name, storage_account_key): self._setup(storage_account_name, storage_account_key) service = ShareServiceClient(self.account_url(storage_account_name, "file"), credential=self.account_key, transport=AiohttpTestTransport()) def callback(response): self.assertTrue('User-Agent' in response.http_request.headers) assert ("customer_user_agent azsdk-python-storage-file-share/{} Python/{} ({})".format( VERSION, platform.python_version(), platform.platform())) in response.http_request.headers['User-Agent'] await service.get_service_properties(raw_response_hook=callback, user_agent='customer_user_agent')
async def test_user_agent_default_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) service = ShareServiceClient(self.account_url(storage_account, "file"), credential=self.account_key, transport=AiohttpTestTransport()) def callback(response): self.assertTrue('User-Agent' in response.http_request.headers) self.assertEqual( response.http_request.headers['User-Agent'], "azsdk-python-storage-file-share/{} Python/{} ({})".format( VERSION, platform.python_version(), platform.platform())) await service.get_service_properties(raw_response_hook=callback)
def __init__(self, arguments): super().__init__(arguments) connection_string = self.get_from_env( "AZURE_STORAGE_CONNECTION_STRING") kwargs = {} if self.args.max_range_size: kwargs['max_range_size'] = self.args.max_range_size if not _ServiceTest.service_client or self.args.no_client_share: _ServiceTest.service_client = SyncShareServiceClient.from_connection_string( conn_str=connection_string, **kwargs) _ServiceTest.async_service_client = AsyncShareServiceClient.from_connection_string( conn_str=connection_string, **kwargs) self.service_client = _ServiceTest.service_client self.async_service_client = _ServiceTest.async_service_client
async def file_service_properties_async(self): # Instantiate the ShareServiceClient from a connection string from azure.storage.fileshare.aio import ShareServiceClient file_service = ShareServiceClient.from_connection_string( self.connection_string) # [START set_service_properties] # Create service properties from azure.storage.fileshare import Metrics, CorsRule, RetentionPolicy # Create metrics for requests statistics hour_metrics = Metrics(enabled=True, include_apis=True, retention_policy=RetentionPolicy(enabled=True, days=5)) minute_metrics = Metrics(enabled=True, include_apis=True, retention_policy=RetentionPolicy(enabled=True, days=5)) # Create CORS rules cors_rule1 = CorsRule(['www.xyz.com'], ['GET']) allowed_origins = ['www.xyz.com', "www.ab.com", "www.bc.com"] allowed_methods = ['GET', 'PUT'] max_age_in_seconds = 500 exposed_headers = [ "x-ms-meta-data*", "x-ms-meta-source*", "x-ms-meta-abc", "x-ms-meta-bcd" ] allowed_headers = [ "x-ms-meta-data*", "x-ms-meta-target*", "x-ms-meta-xyz", "x-ms-meta-foo" ] cors_rule2 = CorsRule(allowed_origins, allowed_methods, max_age_in_seconds=max_age_in_seconds, exposed_headers=exposed_headers, allowed_headers=allowed_headers) cors = [cors_rule1, cors_rule2] async with file_service: # Set the service properties await file_service.set_service_properties(hour_metrics, minute_metrics, cors) # [END set_service_properties] # [START get_service_properties] properties = await file_service.get_service_properties()
async def authentication_shared_access_signature_async(self): # Instantiate a ShareServiceClient using a connection string from azure.storage.fileshare.aio import ShareServiceClient share_service_client = ShareServiceClient.from_connection_string( self.connection_string) # Create a SAS token to use to authenticate a new client from azure.storage.fileshare import generate_account_sas sas_token = generate_account_sas( share_service_client.account_name, share_service_client.credential.account_key, resource_types="object", permission="read", expiry=datetime.utcnow() + timedelta(hours=1))
async def _test_user_agent_append_async(self): service = ShareServiceClient(self.get_file_url(), credential=self.account_key, transport=AiohttpTestTransport()) def callback(response): self.assertTrue('User-Agent' in response.http_request.headers) self.assertEqual( response.http_request.headers['User-Agent'], "azsdk-python-storage-file-share/{} Python/{} ({}) customer_user_agent" .format(VERSION, platform.python_version(), platform.platform())) custom_headers = {'User-Agent': 'customer_user_agent'} await service.get_service_properties(raw_response_hook=callback, headers=custom_headers)
async def _test_transport_closed_only_once_async(self): if TestMode.need_recording_file(self.test_mode): return transport = AioHttpTransport() url = self.get_file_url() credential = self.get_shared_key_credential() prefix = TEST_SHARE_PREFIX share_name = self.get_resource_name(prefix) async with ShareServiceClient(url, credential=credential, transport=transport) as fsc: await fsc.get_service_properties() assert transport.session is not None async with fsc.get_share_client(share_name) as fc: assert transport.session is not None await fsc.get_service_properties() assert transport.session is not None
async def test_transport_closed_only_once_async(self, resource_group, location, storage_account, storage_account_key): if not self.is_live: return self._setup(storage_account, storage_account_key) transport = AioHttpTransport() url = self.get_file_url(storage_account.name) credential = storage_account_key prefix = TEST_SHARE_PREFIX share_name = self.get_resource_name(prefix) async with ShareServiceClient(url, credential=credential, transport=transport) as fsc: await fsc.get_service_properties() assert transport.session is not None async with fsc.get_share_client(share_name) as fc: assert transport.session is not None await fsc.get_service_properties() assert transport.session is not None await self._delete_shares(share_name)
async def test_user_agent_custom_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) custom_app = "TestApp/v1.0" service = ShareServiceClient( self.account_url(storage_account, "file"), credential=self.account_key, user_agent=custom_app, transport=AiohttpTestTransport()) def callback1(response): self.assertTrue('User-Agent' in response.http_request.headers) assert ("TestApp/v1.0 azsdk-python-storage-file-share/{} Python/{} ({})".format( VERSION, platform.python_version(), platform.platform())) in response.http_request.headers['User-Agent'] await service.get_service_properties(raw_response_hook=callback1) def callback2(response): self.assertTrue('User-Agent' in response.http_request.headers) assert ("TestApp/v2.0 TestApp/v1.0 azsdk-python-storage-file-share/{} Python/{} ({})".format( VERSION, platform.python_version(), platform.platform())) in response.http_request.headers['User-Agent'] await service.get_service_properties(raw_response_hook=callback2, user_agent="TestApp/v2.0")
async def test_old_api_copy_file_succeeds_async(self, resource_group, location, storage_account, storage_account_key): fsc = ShareServiceClient(self.account_url(storage_account, "file"), credential=storage_account_key, max_range_size=4 * 1024, api_version=self.api_version_1) share = await self._create_share(fsc) file_name = self._get_file_reference() source_client = share.get_file_client(file_name) await source_client.upload_file(self.short_byte_data) source_prop = await source_client.get_file_properties() file_client = ShareFileClient(self.account_url(storage_account, "file"), share_name=share.share_name, file_path='file1copy', credential=storage_account_key, api_version=self.api_version_1) # Act copy = await file_client.start_copy_from_url(source_client.url) # Assert dest_prop = await file_client.get_file_properties() # to make sure the acl is copied from source self.assertEqual(source_prop['permission_key'], dest_prop['permission_key']) self.assertIsNotNone(copy) self.assertEqual(copy['copy_status'], 'success') self.assertIsNotNone(copy['copy_id']) copy_file = await (await file_client.download_file()).readall() self.assertEqual(copy_file, self.short_byte_data)
def test_service_client_api_version_property(self): service_client = ShareServiceClient( "https://foo.file.core.windows.net/account", credential="fake_key") self.assertEqual(service_client.api_version, self.api_version_2) self.assertEqual(service_client._client._config.version, self.api_version_2) with pytest.raises(AttributeError): service_client.api_version = self.api_version_1 service_client = ShareServiceClient( "https://foo.file.core.windows.net/account", credential="fake_key", api_version=self.api_version_1) self.assertEqual(service_client.api_version, self.api_version_1) self.assertEqual(service_client._client._config.version, self.api_version_1) share_client = service_client.get_share_client("foo") self.assertEqual(share_client.api_version, self.api_version_1) self.assertEqual(share_client._client._config.version, self.api_version_1)
async def authentication_shared_access_key_async(self): # Instantiate a ShareServiceClient using a shared access key # [START create_share_service_client] from azure.storage.fileshare.aio import ShareServiceClient share_service_client = ShareServiceClient( account_url=self.account_url, credential=self.shared_access_key)
def test_create_service_with_custom_account_endpoint_path(self): custom_account_url = "http://local-machine:11002/custom/account/path/" + self.sas_token for service_type in SERVICES.items(): conn_string = 'DefaultEndpointsProtocol=http;AccountName={};AccountKey={};FileEndpoint={};'.format( self.account_name, self.account_key, custom_account_url) # Act service = service_type[0].from_connection_string( conn_string, share_name="foo", directory_path="bar", file_path="baz") # Assert self.assertEqual(service.account_name, self.account_name) self.assertEqual(service.credential.account_name, self.account_name) self.assertEqual(service.credential.account_key, self.account_key) self.assertEqual(service.primary_hostname, 'local-machine:11002/custom/account/path') service = ShareServiceClient(account_url=custom_account_url) self.assertEqual(service.account_name, None) self.assertEqual(service.credential, None) self.assertEqual(service.primary_hostname, 'local-machine:11002/custom/account/path') self.assertTrue( service.url.startswith( 'http://local-machine:11002/custom/account/path/?')) service = ShareClient(account_url=custom_account_url, share_name="foo", snapshot="snap") self.assertEqual(service.account_name, None) self.assertEqual(service.share_name, "foo") self.assertEqual(service.snapshot, "snap") self.assertEqual(service.credential, None) self.assertEqual(service.primary_hostname, 'local-machine:11002/custom/account/path') self.assertTrue( service.url.startswith( 'http://local-machine:11002/custom/account/path/foo?sharesnapshot=snap&' )) service = ShareDirectoryClient(account_url=custom_account_url, share_name='foo', directory_path="bar/baz", snapshot="snap") self.assertEqual(service.account_name, None) self.assertEqual(service.share_name, "foo") self.assertEqual(service.directory_path, "bar/baz") self.assertEqual(service.snapshot, "snap") self.assertEqual(service.credential, None) self.assertEqual(service.primary_hostname, 'local-machine:11002/custom/account/path') self.assertTrue( service.url.startswith( 'http://local-machine:11002/custom/account/path/foo/bar%2Fbaz?sharesnapshot=snap&' )) service = ShareDirectoryClient(account_url=custom_account_url, share_name='foo', directory_path="") self.assertEqual(service.account_name, None) self.assertEqual(service.share_name, "foo") self.assertEqual(service.directory_path, "") self.assertEqual(service.snapshot, None) self.assertEqual(service.credential, None) self.assertEqual(service.primary_hostname, 'local-machine:11002/custom/account/path') self.assertTrue( service.url.startswith( 'http://local-machine:11002/custom/account/path/foo?')) service = ShareFileClient(account_url=custom_account_url, share_name="foo", file_path="bar/baz/file", snapshot="snap") self.assertEqual(service.account_name, None) self.assertEqual(service.share_name, "foo") self.assertEqual(service.directory_path, "bar/baz") self.assertEqual(service.file_path, ["bar", "baz", "file"]) self.assertEqual(service.file_name, "file") self.assertEqual(service.snapshot, "snap") self.assertEqual(service.credential, None) self.assertEqual(service.primary_hostname, 'local-machine:11002/custom/account/path') self.assertTrue( service.url.startswith( 'http://local-machine:11002/custom/account/path/foo/bar/baz/file?sharesnapshot=snap&' )) service = ShareFileClient(account_url=custom_account_url, share_name="foo", file_path="file") self.assertEqual(service.account_name, None) self.assertEqual(service.share_name, "foo") self.assertEqual(service.directory_path, "") self.assertEqual(service.file_path, ["file"]) self.assertEqual(service.file_name, "file") self.assertEqual(service.snapshot, None) self.assertEqual(service.credential, None) self.assertEqual(service.primary_hostname, 'local-machine:11002/custom/account/path') self.assertTrue( service.url.startswith( 'http://local-machine:11002/custom/account/path/foo/file?'))
class StorageShareTest(FileTestCase): def setUp(self): super(StorageShareTest, self).setUp() file_url = self.get_file_url() credentials = self.get_shared_key_credential() self.fsc = ShareServiceClient(account_url=file_url, credential=credentials, transport=AiohttpTestTransport()) loop = asyncio.get_event_loop() loop.run_until_complete(self.fsc.__aenter__()) self.test_shares = [] def tearDown(self): if not self.is_playback(): loop = asyncio.get_event_loop() try: for s in self.test_shares: loop.run_until_complete( self.fsc.delete_share(s.share_name, delete_snapshots=True)) loop.run_until_complete(self.fsc.__aexit__()) except: pass return super(StorageShareTest, self).tearDown() # --Helpers----------------------------------------------------------------- def _get_share_reference(self, prefix=TEST_SHARE_PREFIX): share_name = self.get_resource_name(prefix) share = self.fsc.get_share_client(share_name) self.test_shares.append(share) return share async def _create_share(self, prefix=TEST_SHARE_PREFIX): share_client = self._get_share_reference(prefix) share = await share_client.create_share() return share_client # --Test cases for shares ----------------------------------------- async def _test_create_share_async(self): # Arrange share = self._get_share_reference() # Act created = await share.create_share() # Assert self.assertTrue(created) @record def test_create_share_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_create_share_async()) async def _test_create_share_snapshot_async(self): # Arrange share = self._get_share_reference() # Act created = await share.create_share() snapshot = await share.create_snapshot() # Assert self.assertTrue(created) self.assertIsNotNone(snapshot['snapshot']) self.assertIsNotNone(snapshot['etag']) self.assertIsNotNone(snapshot['last_modified']) @record def test_create_share_snapshot_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_create_share_snapshot_async()) async def _test_create_snapshot_with_metadata_async(self): # Arrange share = self._get_share_reference() metadata = {"test1": "foo", "test2": "bar"} metadata2 = {"test100": "foo100", "test200": "bar200"} # Act created = await share.create_share(metadata=metadata) snapshot = await share.create_snapshot(metadata=metadata2) share_props = await share.get_share_properties() snapshot_client = ShareClient( self.get_file_url(), share_name=share.share_name, snapshot=snapshot, credential=self.settings.STORAGE_ACCOUNT_KEY) snapshot_props = await snapshot_client.get_share_properties() # Assert self.assertTrue(created) self.assertIsNotNone(snapshot['snapshot']) self.assertIsNotNone(snapshot['etag']) self.assertIsNotNone(snapshot['last_modified']) self.assertEqual(share_props.metadata, metadata) self.assertEqual(snapshot_props.metadata, metadata2) @record def test_create_snapshot_with_metadata_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_create_snapshot_with_metadata_async()) async def _test_delete_share_with_snapshots_async(self): # Arrange share = self._get_share_reference() await share.create_share() snapshot = await share.create_snapshot() # Act with self.assertRaises(HttpResponseError): await share.delete_share() deleted = await share.delete_share(delete_snapshots=True) self.assertIsNone(deleted) @record def test_delete_share_with_snapshots_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_delete_share_with_snapshots_async()) async def _test_delete_snapshot_async(self): # Arrange share = self._get_share_reference() await share.create_share() snapshot = await share.create_snapshot() # Act with self.assertRaises(HttpResponseError): await share.delete_share() snapshot_client = ShareClient( self.get_file_url(), share_name=share.share_name, snapshot=snapshot, credential=self.settings.STORAGE_ACCOUNT_KEY) deleted = await snapshot_client.delete_share() self.assertIsNone(deleted) @record def test_delete_snapshot_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_delete_snapshot_async()) async def _test_create_share_fail_on_exist(self): # Arrange share = self._get_share_reference() # Act created = await share.create_share() # Assert self.assertTrue(created) @record def test_create_share_fail_on_exist(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_create_share_fail_on_exist()) async def _test_create_share_with_already_existing_share_fail_on_exist_async( self): # Arrange share = self._get_share_reference() # Act created = await share.create_share() with self.assertRaises(HttpResponseError): await share.create_share() # Assert self.assertTrue(created) @record def test_create_share_with_already_existing_share_fail_on_exist_async( self): loop = asyncio.get_event_loop() loop.run_until_complete( self. _test_create_share_with_already_existing_share_fail_on_exist_async( )) async def _test_create_share_with_metadata_async(self): # Arrange metadata = {'hello': 'world', 'number': '42'} # Act client = self._get_share_reference() created = await client.create_share(metadata=metadata) # Assert self.assertTrue(created) props = await client.get_share_properties() self.assertDictEqual(props.metadata, metadata) @record def test_create_share_with_metadata_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_create_share_with_metadata_async()) async def _test_create_share_with_quota_async(self): # Arrange # Act client = self._get_share_reference() created = await client.create_share(quota=1) # Assert props = await client.get_share_properties() self.assertTrue(created) self.assertEqual(props.quota, 1) @record def test_create_share_with_quota_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_create_share_with_quota_async()) async def _test_share_exists_async(self): # Arrange share = await self._create_share() # Act exists = await share.get_share_properties() # Assert self.assertTrue(exists) @record def test_share_exists_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_share_exists_async()) async def _test_share_not_exists_async(self): # Arrange share = self._get_share_reference() # Act with self.assertRaises(ResourceNotFoundError): await share.get_share_properties() # Assert @record def test_share_not_exists_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_share_not_exists_async()) async def _test_share_snapshot_exists_async(self): # Arrange share = await self._create_share() snapshot = await share.create_snapshot() # Act snapshot_client = self.fsc.get_share_client(share.share_name, snapshot=snapshot) exists = await snapshot_client.get_share_properties() # Assert self.assertTrue(exists) @record def test_share_snapshot_exists_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_share_snapshot_exists_async()) async def _test_share_snapshot_not_exists_async(self): # Arrange share = await self._create_share() made_up_snapshot = '2017-07-19T06:53:46.0000000Z' # Act snapshot_client = self.fsc.get_share_client(share.share_name, snapshot=made_up_snapshot) with self.assertRaises(ResourceNotFoundError): await snapshot_client.get_share_properties() # Assert @record def test_share_snapshot_not_exists_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_share_snapshot_not_exists_async()) async def _test_unicode_create_share_unicode_name_async(self): # Arrange share_name = u'啊齄丂狛狜' # Act with self.assertRaises(HttpResponseError): # not supported - share name must be alphanumeric, lowercase client = self.fsc.get_share_client(share_name) await client.create_share() # Assert @record def test_unicode_create_share_unicode_name_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_unicode_create_share_unicode_name_async()) async def _test_list_shares_no_options_async(self): # Arrange share = await self._create_share() # Act shares = [] async for s in self.fsc.list_shares(): shares.append(s) # Assert self.assertIsNotNone(shares) self.assertGreaterEqual(len(shares), 1) self.assertIsNotNone(shares[0]) self.assertNamedItemInContainer(shares, share.share_name) @record def test_list_shares_no_options_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_list_shares_no_options_async()) async def _test_list_shares_with_snapshot_async(self): # Arrange share = self._get_share_reference() await share.create_share() snapshot1 = await share.create_snapshot() snapshot2 = await share.create_snapshot() # Act shares = self.fsc.list_shares(include_snapshots=True) # Assert self.assertIsNotNone(shares) all_shares = [] async for s in shares: all_shares.append(s) self.assertEqual(len(all_shares), 3) self.assertNamedItemInContainer(all_shares, share.share_name) self.assertNamedItemInContainer(all_shares, snapshot1['snapshot']) self.assertNamedItemInContainer(all_shares, snapshot2['snapshot']) @record def test_list_shares_with_snapshot_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_list_shares_with_snapshot_async()) async def _test_list_shares_with_prefix_async(self): # Arrange share = self._get_share_reference() await share.create_share() # Act shares = [] async for s in self.fsc.list_shares(name_starts_with=share.share_name): shares.append(s) # Assert self.assertEqual(len(shares), 1) self.assertIsNotNone(shares[0]) self.assertEqual(shares[0].name, share.share_name) self.assertIsNone(shares[0].metadata) @record def test_list_shares_with_prefix_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_list_shares_with_prefix_async()) async def _test_list_shares_with_include_metadata_async(self): # Arrange metadata = {'hello': 'world', 'number': '42'} share = self._get_share_reference() await share.create_share(metadata=metadata) # Act shares = [] async for s in self.fsc.list_shares(share.share_name, include_metadata=True): shares.append(s) # Assert self.assertIsNotNone(shares) self.assertGreaterEqual(len(shares), 1) self.assertIsNotNone(shares[0]) self.assertNamedItemInContainer(shares, share.share_name) self.assertDictEqual(shares[0].metadata, metadata) @record def test_list_shares_with_include_metadata_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_list_shares_with_include_metadata_async()) async def _test_list_shares_with_num_results_and_marker_async(self): # Arrange prefix = 'listshare' share_names = [] for i in range(0, 4): share = await self._create_share(prefix + str(i)) share_names.append(share.share_name) share_names.sort() # Act generator1 = self.fsc.list_shares(prefix, results_per_page=2).by_page() shares1 = [] async for s in await generator1.__anext__(): shares1.append(s) generator2 = self.fsc.list_shares(prefix, results_per_page=2).by_page( continuation_token=generator1.continuation_token) shares2 = [] async for s in await generator2.__anext__(): shares2.append(s) # Assert self.assertIsNotNone(shares1) self.assertEqual(len(shares1), 2) self.assertNamedItemInContainer(shares1, share_names[0]) self.assertNamedItemInContainer(shares1, share_names[1]) self.assertIsNotNone(shares2) self.assertEqual(len(shares2), 2) self.assertNamedItemInContainer(shares2, share_names[2]) self.assertNamedItemInContainer(shares2, share_names[3]) @record def test_list_shares_with_num_results_and_marker_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_list_shares_with_num_results_and_marker_async()) async def _test_set_share_metadata_async(self): # Arrange share = await self._create_share() metadata = {'hello': 'world', 'number': '42'} # Act await share.set_share_metadata(metadata) # Assert props = await share.get_share_properties() md = props.metadata self.assertDictEqual(md, metadata) @record def test_set_share_metadata_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_set_share_metadata_async()) async def _test_get_share_metadata_async(self): # Arrange metadata = {'hello': 'world', 'number': '42'} # Act client = self._get_share_reference() created = await client.create_share(metadata=metadata) # Assert self.assertTrue(created) props = await client.get_share_properties() self.assertDictEqual(props.metadata, metadata) @record def test_get_share_metadata_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_get_share_metadata_async()) async def _test_get_share_metadata_with_snapshot_async(self): # Arrange metadata = {'hello': 'world', 'number': '42'} # Act client = self._get_share_reference() created = await client.create_share(metadata=metadata) snapshot = await client.create_snapshot() snapshot_client = self.fsc.get_share_client(client.share_name, snapshot=snapshot) # Assert self.assertTrue(created) props = await snapshot_client.get_share_properties() self.assertDictEqual(props.metadata, metadata) @record def test_get_share_metadata_with_snapshot_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_get_share_metadata_with_snapshot_async()) async def _test_set_share_properties_async(self): # Arrange share = await self._create_share() await share.set_share_quota(1) # Act props = await share.get_share_properties() # Assert self.assertIsNotNone(props) self.assertEqual(props.quota, 1) @record def test_set_share_properties_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_set_share_properties_async()) async def _test_delete_share_with_existing_share_async(self): # Arrange share = self._get_share_reference() await share.create_share() # Act deleted = await share.delete_share() # Assert self.assertIsNone(deleted) @record def test_delete_share_with_existing_share_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_delete_share_with_existing_share_async()) async def _test_delete_share_with_existing_share_fail_not_exist_async( self): # Arrange client = self._get_share_reference() # Act with LogCaptured(self) as log_captured: with self.assertRaises(HttpResponseError): await client.delete_share() log_as_str = log_captured.getvalue() @record def test_delete_share_with_existing_share_fail_not_exist_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_delete_share_with_existing_share_fail_not_exist_async()) async def _test_delete_share_with_non_existing_share_async(self): # Arrange client = self._get_share_reference() # Act with LogCaptured(self) as log_captured: with self.assertRaises(HttpResponseError): deleted = await client.delete_share() log_as_str = log_captured.getvalue() self.assertTrue('ERROR' not in log_as_str) @record def test_delete_share_with_non_existing_share_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_delete_share_with_non_existing_share_async()) async def _test_delete_share_with_non_existing_share_fail_not_exist_async( self): # Arrange client = self._get_share_reference() # Act with LogCaptured(self) as log_captured: with self.assertRaises(HttpResponseError): await client.delete_share() log_as_str = log_captured.getvalue() @record def test_delete_share_with_non_existing_share_fail_not_exist_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self. _test_delete_share_with_non_existing_share_fail_not_exist_async()) async def _test_get_share_stats_async(self): # Arrange share = self._get_share_reference() await share.create_share() # Act share_usage = await share.get_share_stats() # Assert self.assertEqual(share_usage, 0) @record def test_get_share_stats_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_get_share_stats_async()) async def _test_set_share_acl_async(self): # Arrange share = self._get_share_reference() await share.create_share() # Act resp = await share.set_share_access_policy(signed_identifiers=dict()) # Assert acl = await share.get_share_access_policy() self.assertIsNotNone(acl) @record def test_set_share_acl_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_set_share_acl_async()) async def _test_set_share_acl_with_empty_signed_identifiers_async(self): # Arrange share = self._get_share_reference() await share.create_share() # Act resp = await share.set_share_access_policy(dict()) # Assert acl = await share.get_share_access_policy() self.assertIsNotNone(acl) self.assertEqual(len(acl.get('signed_identifiers')), 0) @record def test_set_share_acl_with_empty_signed_identifiers_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_set_share_acl_with_empty_signed_identifiers_async()) async def _test_set_share_acl_with_signed_identifiers_async(self): # Arrange share = self._get_share_reference() await share.create_share() # Act identifiers = dict() identifiers['testid'] = AccessPolicy( permission=ShareSasPermissions(write=True), expiry=datetime.utcnow() + timedelta(hours=1), start=datetime.utcnow() - timedelta(minutes=1), ) resp = await share.set_share_access_policy(identifiers) # Assert acl = await share.get_share_access_policy() self.assertIsNotNone(acl) self.assertEqual(len(acl['signed_identifiers']), 1) self.assertEqual(acl['signed_identifiers'][0].id, 'testid') @record def test_set_share_acl_with_signed_identifiers_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_set_share_acl_with_signed_identifiers_async()) async def _test_set_share_acl_too_many_ids_async(self): # Arrange share = self._get_share_reference() await share.create_share() # Act identifiers = dict() for i in range(0, 6): identifiers['id{}'.format(i)] = AccessPolicy() # Assert with self.assertRaises(ValueError) as e: await share.set_share_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_share_acl_too_many_ids_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_set_share_acl_too_many_ids_async()) async def _test_list_directories_and_files_async(self): # Arrange share = await self._create_share() dir0 = share.get_directory_client() await dir0.upload_file('file1', 'data1') dir1 = share.get_directory_client('dir1') await dir1.create_directory() await dir1.upload_file('file2', 'data2') dir2 = share.get_directory_client('dir2') await dir2.create_directory() # Act resp = [] async for d in share.list_directories_and_files(): resp.append(d) # Assert self.assertIsNotNone(resp) self.assertEqual(len(resp), 3) self.assertIsNotNone(resp[0]) self.assertNamedItemInContainer(resp, 'dir1') self.assertNamedItemInContainer(resp, 'dir2') self.assertNamedItemInContainer(resp, 'file1') @record def test_list_directories_and_files_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_list_directories_and_files_async()) async def _test_list_directories_and_files_with_snapshot_async(self): # Arrange share_name = await self._create_share() dir1 = share_name.get_directory_client('dir1') await dir1.create_directory() dir2 = share_name.get_directory_client('dir2') await dir2.create_directory() snapshot1 = await share_name.create_snapshot() dir3 = share_name.get_directory_client('dir3') await dir3.create_directory() file1 = share_name.get_file_client('file1') await file1.upload_file('data') # Act snapshot_client = self.fsc.get_share_client(share_name.share_name, snapshot=snapshot1) resp = [] async for d in snapshot_client.list_directories_and_files(): resp.append(d) # Assert self.assertIsNotNone(resp) self.assertEqual(len(resp), 2) self.assertIsNotNone(resp[0]) self.assertNamedItemInContainer(resp, 'dir1') self.assertNamedItemInContainer(resp, 'dir2') @record def test_list_directories_and_files_with_snapshot_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_list_directories_and_files_with_snapshot_async()) async def _test_list_directories_and_files_with_num_results_async(self): # Arrange share_name = await self._create_share() dir1 = await share_name.create_directory('dir1') root = share_name.get_directory_client() await root.upload_file('filea1', '1024') await root.upload_file('filea2', '1024') await root.upload_file('filea3', '1024') await root.upload_file('fileb1', '1024') # Act result = share_name.list_directories_and_files( results_per_page=2).by_page() results = [] async for r in await result.__anext__(): results.append(r) # Assert self.assertIsNotNone(result) self.assertEqual(len(results), 2) self.assertNamedItemInContainer(results, 'dir1') self.assertNamedItemInContainer(results, 'filea1') @record def test_list_directories_and_files_with_num_results_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_list_directories_and_files_with_num_results_async()) async def _test_list_directories_and_files_with_num_results_and_marker_async( self): # Arrange share_name = await self._create_share() dir1 = share_name.get_directory_client('dir1') await dir1.create_directory() await dir1.upload_file('filea1', '1024') await dir1.upload_file('filea2', '1024') await dir1.upload_file('filea3', '1024') await dir1.upload_file('fileb1', '1024') # Act generator1 = share_name.list_directories_and_files( 'dir1', results_per_page=2).by_page() result1 = [] async for r in await generator1.__anext__(): result1.append(r) generator2 = share_name.list_directories_and_files( 'dir1', results_per_page=2).by_page( continuation_token=generator1.continuation_token) result2 = [] async for r in await generator2.__anext__(): result2.append(r) # Assert self.assertEqual(len(result1), 2) self.assertEqual(len(result2), 2) self.assertNamedItemInContainer(result1, 'filea1') self.assertNamedItemInContainer(result1, 'filea2') self.assertNamedItemInContainer(result2, 'filea3') self.assertNamedItemInContainer(result2, 'fileb1') self.assertEqual(generator2.continuation_token, None) @record def test_list_directories_and_files_with_num_results_and_marker_async( self): loop = asyncio.get_event_loop() loop.run_until_complete( self. _test_list_directories_and_files_with_num_results_and_marker_async( )) async def _test_list_directories_and_files_with_prefix_async(self): # Arrange share = await self._create_share() dir1 = await share.create_directory('dir1') await share.create_directory('dir1/pref_dir3') await share.create_directory('dir2') root = share.get_directory_client() await root.upload_file('file1', '1024') await dir1.upload_file('pref_file2', '1025') await dir1.upload_file('file3', '1025') # Act resp = [] async for d in share.list_directories_and_files( 'dir1', name_starts_with='pref'): resp.append(d) # Assert self.assertIsNotNone(resp) self.assertEqual(len(resp), 2) self.assertIsNotNone(resp[0]) self.assertNamedItemInContainer(resp, 'pref_file2') self.assertNamedItemInContainer(resp, 'pref_dir3') @record def test_list_directories_and_files_with_prefix_async(self): loop = asyncio.get_event_loop() loop.run_until_complete( self._test_list_directories_and_files_with_prefix_async()) async def _test_shared_access_share_async(self): # SAS URL is calculated from storage key, so this test runs live only if TestMode.need_recording_file(self.test_mode): return # Arrange file_name = 'file1' dir_name = 'dir1' data = b'hello world' share = await self._create_share() dir1 = await share.create_directory(dir_name) await dir1.upload_file(file_name, data) token = generate_share_sas( share.account_name, share.share_name, share.credential.account_key, expiry=datetime.utcnow() + timedelta(hours=1), permission=ShareSasPermissions(read=True), ) sas_client = ShareFileClient( self.get_file_url(), share_name=share.share_name, file_path=dir_name + '/' + file_name, credential=token, ) # Act response = requests.get(sas_client.url) # Assert self.assertTrue(response.ok) self.assertEqual(data, response.content) @record def test_shared_access_share_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_shared_access_share_async()) async def _test_create_permission_for_share(self): user_given_permission = "O:S-1-5-21-2127521184-1604012920-1887927527-21560751G:S-1-5-21-2127521184-" \ "1604012920-1887927527-513D:AI(A;;FA;;;SY)(A;;FA;;;BA)(A;;0x1200a9;;;" \ "S-1-5-21-397955417-626881126-188441444-3053964)" share_client = await self._create_share() permission_key = await share_client.create_permission_for_share( user_given_permission) self.assertIsNotNone(permission_key) server_returned_permission = await share_client.get_permission_for_share( permission_key) self.assertIsNotNone(server_returned_permission) permission_key2 = await share_client.create_permission_for_share( server_returned_permission) # the permission key obtained from user_given_permission should be the same as the permission key obtained from # server returned permission self.assertEqual(permission_key, permission_key2) @record def test_create_permission_for_share_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_create_permission_for_share()) async def _test_transport_closed_only_once_async(self): if TestMode.need_recording_file(self.test_mode): return transport = AioHttpTransport() url = self.get_file_url() credential = self.get_shared_key_credential() prefix = TEST_SHARE_PREFIX share_name = self.get_resource_name(prefix) async with ShareServiceClient(url, credential=credential, transport=transport) as fsc: await fsc.get_service_properties() assert transport.session is not None async with fsc.get_share_client(share_name) as fc: assert transport.session is not None await fsc.get_service_properties() assert transport.session is not None @record def test_transport_closed_only_once_async(self): loop = asyncio.get_event_loop() loop.run_until_complete(self._test_transport_closed_only_once_async())
class StorageDirectoryTest(AsyncStorageTestCase): # --Helpers----------------------------------------------------------------- async def _setup(self, storage_account_name, storage_account_key): url = self.account_url(storage_account_name, "file") credential = storage_account_key self.fsc = ShareServiceClient(url, credential=credential, transport=AiohttpTestTransport()) self.share_name = self.get_resource_name('utshare') if not self.is_playback(): try: await self.fsc.create_share(self.share_name) except: pass def _teardown(self, FILE_PATH): if os.path.isfile(FILE_PATH): try: os.remove(FILE_PATH) except: pass # --Test cases for directories ---------------------------------------------- @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_directories_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) # Act created = await share_client.create_directory('dir1') # Assert self.assertTrue(created) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_directories_with_metadata_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) metadata = {'hello': 'world', 'number': '42'} # Act directory = await share_client.create_directory('dir1', metadata=metadata) # Assert props = await directory.get_directory_properties() self.assertDictEqual(props.metadata, metadata) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_directories_fail_on_exist_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) # Act created = await share_client.create_directory('dir1') with self.assertRaises(ResourceExistsError): await share_client.create_directory('dir1') # Assert self.assertTrue(created) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_subdirectories_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') # Act created = await directory.create_subdirectory('dir2') # Assert self.assertTrue(created) self.assertEqual(created.directory_path, 'dir1/dir2') @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_subdirectories_with_metadata_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') metadata = {'hello': 'world', 'number': '42'} # Act created = await directory.create_subdirectory('dir2', metadata=metadata) # Assert self.assertTrue(created) self.assertEqual(created.directory_path, 'dir1/dir2') properties = await created.get_directory_properties() self.assertEqual(properties.metadata, metadata) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_file_in_directory_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) file_data = b'12345678' * 1024 file_name = self.get_resource_name('file') share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') # Act new_file = await directory.upload_file(file_name, file_data) # Assert file_content = await new_file.download_file() file_content = await file_content.readall() self.assertEqual(file_content, file_data) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_file_in_directory_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) file_name = self.get_resource_name('file') share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') new_file = await directory.upload_file(file_name, "hello world") # Act deleted = await directory.delete_file(file_name) # Assert self.assertIsNone(deleted) with self.assertRaises(ResourceNotFoundError): await new_file.get_file_properties() @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_subdirectories_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') await directory.create_subdirectory('dir2') # Act deleted = await directory.delete_subdirectory('dir2') # Assert self.assertIsNone(deleted) subdir = directory.get_subdirectory_client('dir2') with self.assertRaises(ResourceNotFoundError): await subdir.get_directory_properties() @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_directory_properties_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') # Act props = await directory.get_directory_properties() # Assert self.assertIsNotNone(props) self.assertIsNotNone(props.etag) self.assertIsNotNone(props.last_modified) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_directory_properties_with_snapshot_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) metadata = {"test1": "foo", "test2": "bar"} directory = await share_client.create_directory('dir1', metadata=metadata) snapshot1 = await share_client.create_snapshot() metadata2 = {"test100": "foo100", "test200": "bar200"} await directory.set_directory_metadata(metadata2) # Act share_client = self.fsc.get_share_client(self.share_name, snapshot=snapshot1) snap_dir = share_client.get_directory_client('dir1') props = await snap_dir.get_directory_properties() # Assert self.assertIsNotNone(props) self.assertIsNotNone(props.etag) self.assertIsNotNone(props.last_modified) self.assertDictEqual(metadata, props.metadata) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_directory_metadata_with_snapshot_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) metadata = {"test1": "foo", "test2": "bar"} directory = await share_client.create_directory('dir1', metadata=metadata) snapshot1 = await share_client.create_snapshot() metadata2 = {"test100": "foo100", "test200": "bar200"} await directory.set_directory_metadata(metadata2) # Act share_client = self.fsc.get_share_client(self.share_name, snapshot=snapshot1) snap_dir = share_client.get_directory_client('dir1') snapshot_props = await snap_dir.get_directory_properties() # Assert self.assertIsNotNone(snapshot_props.metadata) self.assertDictEqual(metadata, snapshot_props.metadata) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_directory_properties_with_non_existing_directory_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = share_client.get_directory_client('dir1') # Act with self.assertRaises(ResourceNotFoundError): await directory.get_directory_properties() # Assert @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_share_directory_exists_async(self, storage_account_name, storage_account_key): await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') directory2 = share_client.get_directory_client("dir2") exists = await directory.exists() exists2 = await directory2.exists() self.assertTrue(exists) self.assertFalse(exists2) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_directory_exists_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') # Act exists = await directory.get_directory_properties() # Assert self.assertTrue(exists) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_directory_not_exists_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = share_client.get_directory_client('dir1') # Act with self.assertRaises(ResourceNotFoundError): await directory.get_directory_properties() # Assert @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_directory_parent_not_exists_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = share_client.get_directory_client('missing1/missing2') # Act with self.assertRaises(ResourceNotFoundError) as e: await directory.get_directory_properties() # Assert self.assertEqual(e.exception.error_code, StorageErrorCode.parent_not_found) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_directory_exists_with_snapshot_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') snapshot = await share_client.create_snapshot() await directory.delete_directory() # Act share_client = self.fsc.get_share_client(self.share_name, snapshot=snapshot) snap_dir = share_client.get_directory_client('dir1') exists = await snap_dir.get_directory_properties() # Assert self.assertTrue(exists) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_directory_not_exists_with_snapshot_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) snapshot = await share_client.create_snapshot() directory = await share_client.create_directory('dir1') # Act share_client = self.fsc.get_share_client(self.share_name, snapshot=snapshot) snap_dir = share_client.get_directory_client('dir1') with self.assertRaises(ResourceNotFoundError): await snap_dir.get_directory_properties() # Assert @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_set_directory_metadata_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') metadata = {'hello': 'world', 'number': '43'} # Act await directory.set_directory_metadata(metadata) props = await directory.get_directory_properties() # Assert self.assertDictEqual(props.metadata, metadata) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_set_directory_properties_with_empty_smb_properties(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory_client = await share_client.create_directory('dir1') directory_properties_on_creation = await directory_client.get_directory_properties() # Act await directory_client.set_http_headers() directory_properties = await directory_client.get_directory_properties() # Assert # Make sure set empty smb_properties doesn't change smb_properties self.assertEqual(directory_properties_on_creation.creation_time, directory_properties.creation_time) self.assertEqual(directory_properties_on_creation.last_write_time, directory_properties.last_write_time) self.assertEqual(directory_properties_on_creation.permission_key, directory_properties.permission_key) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_set_directory_properties_with_file_permission_key(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory_client = await share_client.create_directory('dir1') directory_properties_on_creation = await directory_client.get_directory_properties() permission_key = directory_properties_on_creation.permission_key last_write_time = directory_properties_on_creation.last_write_time creation_time = directory_properties_on_creation.creation_time new_last_write_time = last_write_time + timedelta(hours=1) new_creation_time = creation_time + timedelta(hours=1) # Act await directory_client.set_http_headers(file_attributes='None', file_creation_time=new_creation_time, file_last_write_time=new_last_write_time, permission_key=permission_key) directory_properties = await directory_client.get_directory_properties() # Assert self.assertIsNotNone(directory_properties) self.assertEqual(directory_properties.creation_time, new_creation_time) self.assertEqual(directory_properties.last_write_time, new_last_write_time) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_subdirectories_and_files_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') await asyncio.gather( directory.create_subdirectory("subdir1"), directory.create_subdirectory("subdir2"), directory.create_subdirectory("subdir3"), directory.upload_file("file1", "data1"), directory.upload_file("file2", "data2"), directory.upload_file("file3", "data3")) # Act list_dir = [] async for d in directory.list_directories_and_files(): list_dir.append(d) # Assert self.assertEqual(len(list_dir), 6) self.assertEqual(len(list_dir), 6) self.assertEqual(list_dir[0]['name'], 'subdir1') self.assertEqual(list_dir[0]['is_directory'], True) self.assertEqual(list_dir[1]['name'], 'subdir2') self.assertEqual(list_dir[1]['is_directory'], True) self.assertEqual(list_dir[2]['name'], 'subdir3') self.assertEqual(list_dir[2]['is_directory'], True) self.assertEqual(list_dir[3]['name'], 'file1') self.assertEqual(list_dir[3]['is_directory'], False) self.assertEqual(list_dir[3]['size'], 5) self.assertEqual(list_dir[4]['name'], 'file2') self.assertEqual(list_dir[4]['is_directory'], False) self.assertEqual(list_dir[4]['size'], 5) self.assertEqual(list_dir[5]['name'], 'file3') self.assertEqual(list_dir[5]['is_directory'], False) self.assertEqual(list_dir[5]['size'], 5) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_subdirectories_and_files_include_other_data_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') await asyncio.gather( directory.create_subdirectory("subdir1"), directory.create_subdirectory("subdir2"), directory.create_subdirectory("subdir3"), directory.upload_file("file1", "data1"), directory.upload_file("file2", "data2"), directory.upload_file("file3", "data3")) # Act list_dir = [] async for d in directory.list_directories_and_files(include=["timestamps", "Etag", "Attributes", "PermissionKey"]): list_dir.append(d) self.assertEqual(len(list_dir), 6) self.assertIsNotNone(list_dir[0].etag) self.assertIsNotNone(list_dir[1].file_attributes) self.assertIsNotNone(list_dir[1].last_access_time) self.assertIsNotNone(list_dir[1].last_write_time) self.assertIsNotNone(list_dir[2].change_time) self.assertIsNotNone(list_dir[2].creation_time) self.assertIsNotNone(list_dir[2].file_id) try: await share_client.delete_share() except: pass @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_subdirectories_and_files_include_extended_info_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') await asyncio.gather( directory.create_subdirectory("subdir1")) # Act list_dir = [] async for d in directory.list_directories_and_files(include_extended_info=True): list_dir.append(d) self.assertEqual(len(list_dir), 1) self.assertIsNotNone(list_dir[0].file_id) self.assertIsNone(list_dir[0].file_attributes) self.assertIsNone(list_dir[0].last_access_time) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_subdirectories_and_files_with_prefix_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') await asyncio.gather( directory.create_subdirectory("subdir1"), directory.create_subdirectory("subdir2"), directory.create_subdirectory("subdir3"), directory.upload_file("file1", "data1"), directory.upload_file("file2", "data2"), directory.upload_file("file3", "data3")) # Act list_dir = [] async for d in directory.list_directories_and_files(name_starts_with="sub"): list_dir.append(d) # Assert self.assertEqual(len(list_dir), 3) self.assertEqual(list_dir[0]['name'], 'subdir1') self.assertEqual(list_dir[0]['is_directory'], True) self.assertEqual(list_dir[1]['name'], 'subdir2') self.assertEqual(list_dir[1]['is_directory'], True) self.assertEqual(list_dir[2]['name'], 'subdir3') self.assertEqual(list_dir[2]['is_directory'], True) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_subdirectories_and_files_with_snapshot_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') await asyncio.gather( directory.create_subdirectory("subdir1"), directory.create_subdirectory("subdir2"), directory.upload_file("file1", "data1")) snapshot = await share_client.create_snapshot() await asyncio.gather( directory.create_subdirectory("subdir3"), directory.upload_file("file2", "data2"), directory.upload_file("file3", "data3")) share_client = self.fsc.get_share_client(self.share_name, snapshot=snapshot) snapshot_dir = share_client.get_directory_client('dir1') # Act list_dir = [] async for d in snapshot_dir.list_directories_and_files(): list_dir.append(d) # Assert self.assertEqual(len(list_dir), 3) self.assertEqual(list_dir[0]['name'], 'subdir1') self.assertEqual(list_dir[0]['is_directory'], True) self.assertEqual(list_dir[1]['name'], 'subdir2') self.assertEqual(list_dir[1]['is_directory'], True) self.assertEqual(list_dir[2]['name'], 'file1') self.assertEqual(list_dir[2]['is_directory'], False) self.assertEqual(list_dir[2]['size'], 5) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_nested_subdirectories_and_files_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') subdir = await directory.create_subdirectory("subdir1") await subdir.create_subdirectory("subdir2") await subdir.create_subdirectory("subdir3") await asyncio.gather( directory.upload_file("file1", "data1"), subdir.upload_file("file2", "data2"), subdir.upload_file("file3", "data3")) # Act list_dir = [] async for d in directory.list_directories_and_files(): list_dir.append(d) # Assert self.assertEqual(len(list_dir), 2) self.assertEqual(list_dir[0]['name'], 'subdir1') self.assertEqual(list_dir[0]['is_directory'], True) self.assertEqual(list_dir[1]['name'], 'file1') self.assertEqual(list_dir[1]['is_directory'], False) self.assertEqual(list_dir[1]['size'], 5) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_directory_with_existing_share_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') # Act deleted = await directory.delete_directory() # Assert self.assertIsNone(deleted) with self.assertRaises(ResourceNotFoundError): await directory.get_directory_properties() @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_directory_with_non_existing_directory_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = share_client.get_directory_client('dir1') # Act with self.assertRaises(ResourceNotFoundError): await directory.delete_directory() # Assert @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_directory_properties_server_encryption_async(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') # Act props = await directory.get_directory_properties() # Assert self.assertIsNotNone(props) self.assertIsNotNone(props.etag) self.assertIsNotNone(props.last_modified) self.assertTrue(props.server_encrypted) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_rename_directory(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) source_directory = await share_client.create_directory('dir1') # Act new_directory = await source_directory.rename_directory('dir2') # Assert props = await new_directory.get_directory_properties() self.assertIsNotNone(props) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_rename_directory_different_directory(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) parent_source_directory = await share_client.create_directory('dir1') source_directory = await parent_source_directory.create_subdirectory('sub1') dest_parent_directory = await share_client.create_directory('dir2') # Act new_directory_path = dest_parent_directory.directory_path + '/sub2' new_directory = await source_directory.rename_directory(new_directory_path) # Assert props = await new_directory.get_directory_properties() self.assertIsNotNone(props) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_rename_directory_ignore_readonly(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) source_directory = await share_client.create_directory('dir1') dest_directory = await share_client.create_directory('dir2') dest_file = dest_directory.get_file_client('test') file_attributes = NTFSAttributes(read_only=True) await dest_file.create_file(1024, file_attributes=file_attributes) # Act new_directory = await source_directory.rename_directory( dest_directory.directory_path + '/' + dest_file.file_name, overwrite=True, ignore_read_only=True) # Assert props = await new_directory.get_directory_properties() self.assertIsNotNone(props) self.assertTrue(props.is_directory) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_rename_directory_file_permission(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) file_permission_key = await share_client.create_permission_for_share(TEST_FILE_PERMISSIONS) source_directory = await share_client.create_directory('dir1') # Act new_directory = await source_directory.rename_directory('dir2', file_permission=TEST_FILE_PERMISSIONS) # Assert props = await new_directory.get_directory_properties() self.assertIsNotNone(props) self.assertEqual(file_permission_key, props.permission_key) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_rename_directory_preserve_permission(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) source_directory = await share_client.create_directory('dir1', file_permission=TEST_FILE_PERMISSIONS) source_props = await source_directory.get_directory_properties() source_permission_key = source_props.permission_key # Act new_directory = await source_directory.rename_directory('dir2', file_permission='preserve') # Assert props = await new_directory.get_directory_properties() self.assertIsNotNone(props) self.assertEqual(source_permission_key, props.permission_key) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_rename_directory_smb_properties(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) source_directory = await share_client.create_directory('dir1') file_attributes = NTFSAttributes(read_only=True, directory=True) file_creation_time = datetime(2022, 1, 26, 10, 9, 30, 500000) file_last_write_time = datetime(2022, 1, 26, 10, 14, 30, 500000) # Act new_directory = await source_directory.rename_directory( 'dir2', file_attributes=file_attributes, file_creation_time=file_creation_time, file_last_write_time=file_last_write_time) # Assert props = await new_directory.get_directory_properties() self.assertIsNotNone(props) self.assertTrue(props.is_directory) self.assertEqual(str(file_attributes), props.file_attributes.replace(' ', '')) self.assertEqual(file_creation_time, props.creation_time) self.assertEqual(file_last_write_time, props.last_write_time) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_rename_directory_dest_lease(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) source_directory = await share_client.create_directory('dir1') dest_directory = await share_client.create_directory('dir2') dest_file = await dest_directory.upload_file('test', b'Hello World') lease = await dest_file.acquire_lease() # Act new_directory = await source_directory.rename_directory( dest_directory.directory_path + '/' + dest_file.file_name, overwrite=True, lease=lease) # Assert props = await new_directory.get_directory_properties() self.assertIsNotNone(props) self.assertTrue(props.is_directory) @pytest.mark.live_test_only @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_rename_directory_share_sas(self, storage_account_name, storage_account_key): # Arrange await self._setup(storage_account_name, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) token = generate_share_sas( share_client.account_name, share_client.share_name, share_client.credential.account_key, expiry=datetime.utcnow() + timedelta(hours=1), permission=ShareSasPermissions(read=True, write=True)) source_directory = ShareDirectoryClient( self.account_url(storage_account_name, 'file'), share_client.share_name, 'dir1', credential=token) await source_directory.create_directory() # Act new_directory = await source_directory.rename_directory('dir2' + '?' + token) # Assert props = await new_directory.get_directory_properties() self.assertIsNotNone(props)
async def create_client_with_connection_string_async(self): # Instantiate the ShareServiceClient from a connection string from azure.storage.fileshare.aio import ShareServiceClient file_service = ShareServiceClient.from_connection_string( self.connection_string)
class StorageShareTest(AsyncStorageTestCase): def _setup(self, storage_account, storage_account_key): file_url = self.account_url(storage_account, "file") credentials = storage_account_key self.fsc = ShareServiceClient(account_url=file_url, credential=credentials, transport=AiohttpTestTransport()) self.test_shares = [] def _teardown(self, FILE_PATH): if os.path.isfile(FILE_PATH): try: os.remove(FILE_PATH) except: pass async def _delete_shares(self, prefix=TEST_SHARE_PREFIX): async for l in self.fsc.list_shares(include_snapshots=True): try: await self.fsc.delete_share(l.name, delete_snapshots=True) except: pass # --Helpers----------------------------------------------------------------- def _get_share_reference(self, prefix=TEST_SHARE_PREFIX): share_name = self.get_resource_name(prefix) share = self.fsc.get_share_client(share_name) self.test_shares.append(share) return share async def _create_share(self, prefix=TEST_SHARE_PREFIX): share_client = self._get_share_reference(prefix) try: await share_client.create_share() except: pass return share_client # --Test cases for shares ----------------------------------------- @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_share_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() # Act created = await share.create_share() # Assert self.assertTrue(created) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_share_snapshot_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() # Act created = await share.create_share() snapshot = await share.create_snapshot() # Assert self.assertTrue(created) self.assertIsNotNone(snapshot['snapshot']) self.assertIsNotNone(snapshot['etag']) self.assertIsNotNone(snapshot['last_modified']) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_snapshot_with_metadata_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() metadata = {"test1": "foo", "test2": "bar"} metadata2 = {"test100": "foo100", "test200": "bar200"} # Act created = await share.create_share(metadata=metadata) snapshot = await share.create_snapshot(metadata=metadata2) share_props = await share.get_share_properties() snapshot_client = ShareClient(self.account_url(storage_account, "file"), share_name=share.share_name, snapshot=snapshot, credential=storage_account_key) snapshot_props = await snapshot_client.get_share_properties() # Assert self.assertTrue(created) self.assertIsNotNone(snapshot['snapshot']) self.assertIsNotNone(snapshot['etag']) self.assertIsNotNone(snapshot['last_modified']) self.assertEqual(share_props.metadata, metadata) self.assertEqual(snapshot_props.metadata, metadata2) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_share_with_snapshots_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() await share.create_share() snapshot = await share.create_snapshot() # Act with self.assertRaises(HttpResponseError): await share.delete_share() deleted = await share.delete_share(delete_snapshots=True) self.assertIsNone(deleted) await self._delete_shares(share.share_name) @pytest.mark.playback_test_only @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_undelete_share(self, resource_group, location, storage_account, storage_account_key): # share soft delete should enabled by SRP call or use armclient, so make this test as playback only. self._setup(storage_account, storage_account_key) share_client = await self._create_share(prefix="sharerestore") # Act await share_client.delete_share() # to make sure the share deleted with self.assertRaises(ResourceNotFoundError): await share_client.get_share_properties() share_list = list() async for share in self.fsc.list_shares(include_deleted=True): share_list.append(share) self.assertTrue(len(share_list) >= 1) for share in share_list: # find the deleted share and restore it if share.deleted and share.name == share_client.share_name: if self.is_live: time.sleep(60) restored_share_client = await self.fsc.undelete_share( share.name, share.version) # to make sure the deleted share is restored props = await restored_share_client.get_share_properties() self.assertIsNotNone(props) break @pytest.mark.playback_test_only @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_restore_to_existing_share(self, resource_group, location, storage_account, storage_account_key): # share soft delete should enabled by SRP call or use armclient, so make this test as playback only. self._setup(storage_account, storage_account_key) # Act share_client = await self._create_share() await share_client.delete_share() # to make sure the share deleted with self.assertRaises(ResourceNotFoundError): await share_client.get_share_properties() # create a share with the same name as the deleted one if self.is_live: time.sleep(30) await share_client.create_share() share_list = [] async for share in self.fsc.list_shares(include_deleted=True): share_list.append(share) self.assertTrue(len(share_list) >= 1) for share in share_list: # find the deleted share and restore it if share.deleted and share.name == share_client.share_name: with self.assertRaises(HttpResponseError): await self.fsc.undelete_share(share.name, share.version) break @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_snapshot_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() await share.create_share() snapshot = await share.create_snapshot() # Act with self.assertRaises(HttpResponseError): await share.delete_share() snapshot_client = ShareClient(self.account_url(storage_account, "file"), share_name=share.share_name, snapshot=snapshot, credential=storage_account_key) deleted = await snapshot_client.delete_share() self.assertIsNone(deleted) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_share_fail_on_exist(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() # Act created = await share.create_share() # Assert self.assertTrue(created) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_share_with_already_existing_share_fail_on_exist_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() # Act created = await share.create_share() with self.assertRaises(HttpResponseError): await share.create_share() # Assert self.assertTrue(created) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_share_with_metadata_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) metadata = {'hello': 'world', 'number': '42'} # Act client = self._get_share_reference() created = await client.create_share(metadata=metadata) # Assert self.assertTrue(created) props = await client.get_share_properties() self.assertDictEqual(props.metadata, metadata) await self._delete_shares(client.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_share_with_quota_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) # Act client = self._get_share_reference() created = await client.create_share(quota=1) # Assert props = await client.get_share_properties() self.assertTrue(created) self.assertEqual(props.quota, 1) await self._delete_shares(client.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_share_exists_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = await self._create_share() # Act exists = await share.get_share_properties() # Assert self.assertTrue(exists) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_share_not_exists_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() # Act with self.assertRaises(ResourceNotFoundError): await share.get_share_properties() # Assert await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_share_snapshot_exists_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = await self._create_share() snapshot = await share.create_snapshot() # Act snapshot_client = self.fsc.get_share_client(share.share_name, snapshot=snapshot) exists = await snapshot_client.get_share_properties() # Assert self.assertTrue(exists) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_share_snapshot_not_exists_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = await self._create_share() made_up_snapshot = '2017-07-19T06:53:46.0000000Z' # Act snapshot_client = self.fsc.get_share_client(share.share_name, snapshot=made_up_snapshot) with self.assertRaises(ResourceNotFoundError): await snapshot_client.get_share_properties() # Assert await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_unicode_create_share_unicode_name_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share_name = u'啊齄丂狛狜' # Act with self.assertRaises(HttpResponseError): # not supported - share name must be alphanumeric, lowercase client = self.fsc.get_share_client(share_name) await client.create_share() # Assert await self._delete_shares(share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_shares_no_options_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = await self._create_share() # Act shares = [] async for s in self.fsc.list_shares(): shares.append(s) # Assert self.assertIsNotNone(shares) self.assertGreaterEqual(len(shares), 1) self.assertIsNotNone(shares[0]) self.assertNamedItemInContainer(shares, share.share_name) await self._delete_shares(share.share_name) @pytest.mark.live_test_only @GlobalResourceGroupPreparer() @StorageAccountPreparer(random_name_enabled=True, sku='premium_LRS', name_prefix='pyacrstorage', kind='FileStorage') @AsyncStorageTestCase.await_prepared_test async def test_list_shares_no_options_for_premium_account_async( self, resource_group, location, storage_account, storage_account_key): # TODO: add recordings to this test self._setup(storage_account, storage_account_key) share = await self._create_share() # Act shares = [] async for s in self.fsc.list_shares(): shares.append(s) # Assert self.assertIsNotNone(shares) self.assertGreaterEqual(len(shares), 1) self.assertIsNotNone(shares[0]) self.assertIsNotNone(shares[0].provisioned_iops) self.assertIsNotNone(shares[0].provisioned_ingress_mbps) self.assertIsNotNone(shares[0].provisioned_egress_mbps) self.assertIsNotNone(shares[0].next_allowed_quota_downgrade_time) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_shares_with_snapshot_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() await share.create_share() snapshot1 = await share.create_snapshot() snapshot2 = await share.create_snapshot() # Act shares = self.fsc.list_shares(include_snapshots=True) # Assert self.assertIsNotNone(shares) all_shares = [] async for s in shares: all_shares.append(s) self.assertEqual(len(all_shares), 3) self.assertNamedItemInContainer(all_shares, share.share_name) self.assertNamedItemInContainer(all_shares, snapshot1['snapshot']) self.assertNamedItemInContainer(all_shares, snapshot2['snapshot']) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_shares_with_prefix_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() await share.create_share() # Act shares = [] async for s in self.fsc.list_shares(name_starts_with=share.share_name): shares.append(s) # Assert self.assertEqual(len(shares), 1) self.assertIsNotNone(shares[0]) self.assertEqual(shares[0].name, share.share_name) self.assertIsNone(shares[0].metadata) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_shares_with_include_metadata_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) metadata = {'hello': 'world', 'number': '42'} share = self._get_share_reference() await share.create_share(metadata=metadata) # Act shares = [] async for s in self.fsc.list_shares(share.share_name, include_metadata=True): shares.append(s) # Assert self.assertIsNotNone(shares) self.assertGreaterEqual(len(shares), 1) self.assertIsNotNone(shares[0]) self.assertNamedItemInContainer(shares, share.share_name) self.assertDictEqual(shares[0].metadata, metadata) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_shares_with_num_results_and_marker_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) prefix = 'listshare' share_names = [] for i in range(0, 4): share = await self._create_share(prefix + str(i)) share_names.append(share.share_name) share_names.sort() # Act generator1 = self.fsc.list_shares(prefix, results_per_page=2).by_page() shares1 = [] async for s in await generator1.__anext__(): shares1.append(s) generator2 = self.fsc.list_shares(prefix, results_per_page=2).by_page( continuation_token=generator1.continuation_token) shares2 = [] async for s in await generator2.__anext__(): shares2.append(s) # Assert self.assertIsNotNone(shares1) self.assertEqual(len(shares1), 2) self.assertNamedItemInContainer(shares1, share_names[0]) self.assertNamedItemInContainer(shares1, share_names[1]) self.assertIsNotNone(shares2) self.assertEqual(len(shares2), 2) self.assertNamedItemInContainer(shares2, share_names[2]) self.assertNamedItemInContainer(shares2, share_names[3]) await self._delete_shares(prefix) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_set_share_metadata_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = await self._create_share() metadata = {'hello': 'world', 'number': '42'} # Act await share.set_share_metadata(metadata) # Assert props = await share.get_share_properties() md = props.metadata self.assertDictEqual(md, metadata) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_share_metadata_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) metadata = {'hello': 'world', 'number': '42'} # Act client = self._get_share_reference() created = await client.create_share(metadata=metadata) # Assert self.assertTrue(created) props = await client.get_share_properties() self.assertDictEqual(props.metadata, metadata) await self._delete_shares(client.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_share_metadata_with_snapshot_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) metadata = {'hello': 'world', 'number': '42'} # Act client = self._get_share_reference() created = await client.create_share(metadata=metadata) snapshot = await client.create_snapshot() snapshot_client = self.fsc.get_share_client(client.share_name, snapshot=snapshot) # Assert self.assertTrue(created) props = await snapshot_client.get_share_properties() self.assertDictEqual(props.metadata, metadata) await self._delete_shares(client.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_set_share_properties_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = await self._create_share() await share.set_share_quota(1) # Act props = await share.get_share_properties() # Assert self.assertIsNotNone(props) self.assertEqual(props.quota, 1) await self._delete_shares(share.share_name) @GlobalResourceGroupPreparer() @StorageAccountPreparer(random_name_enabled=True, sku='premium_LRS', name_prefix='pyacrstorage', kind='FileStorage') @AsyncStorageTestCase.await_prepared_test async def test_get_share_properties_for_premium_account_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = await self._create_share() # Act props = await share.get_share_properties() # Assert self.assertIsNotNone(props) self.assertIsNotNone(props.quota) self.assertIsNotNone(props.quota) self.assertIsNotNone(props.provisioned_iops) self.assertIsNotNone(props.provisioned_ingress_mbps) self.assertIsNotNone(props.provisioned_egress_mbps) self.assertIsNotNone(props.next_allowed_quota_downgrade_time) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_share_with_existing_share_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() await share.create_share() # Act deleted = await share.delete_share() # Assert self.assertIsNone(deleted) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_share_with_existing_share_fail_not_exist_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) client = self._get_share_reference() # Act with LogCaptured(self) as log_captured: with self.assertRaises(HttpResponseError): await client.delete_share() log_as_str = log_captured.getvalue() await self._delete_shares(client.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_share_with_non_existing_share_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) client = self._get_share_reference() # Act with LogCaptured(self) as log_captured: with self.assertRaises(HttpResponseError): deleted = await client.delete_share() log_as_str = log_captured.getvalue() self.assertTrue('ERROR' not in log_as_str) await self._delete_shares(client.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_share_with_non_existing_share_fail_not_exist_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) client = self._get_share_reference() # Act with LogCaptured(self) as log_captured: with self.assertRaises(HttpResponseError): await client.delete_share() log_as_str = log_captured.getvalue() await self._delete_shares(client.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_share_stats_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() await share.create_share() # Act share_usage = await share.get_share_stats() # Assert self.assertEqual(share_usage, 0) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_set_share_acl_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() await share.create_share() # Act resp = await share.set_share_access_policy(signed_identifiers=dict()) # Assert acl = await share.get_share_access_policy() self.assertIsNotNone(acl) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_set_share_acl_with_empty_signed_identifiers_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() await share.create_share() # Act resp = await share.set_share_access_policy(dict()) # Assert acl = await share.get_share_access_policy() self.assertIsNotNone(acl) self.assertEqual(len(acl.get('signed_identifiers')), 0) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_set_share_acl_with_signed_identifiers_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() await share.create_share() # Act identifiers = dict() identifiers['testid'] = AccessPolicy( permission=ShareSasPermissions(write=True), expiry=datetime.utcnow() + timedelta(hours=1), start=datetime.utcnow() - timedelta(minutes=1), ) resp = await share.set_share_access_policy(identifiers) # Assert acl = await share.get_share_access_policy() self.assertIsNotNone(acl) self.assertEqual(len(acl['signed_identifiers']), 1) self.assertEqual(acl['signed_identifiers'][0].id, 'testid') await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_set_share_acl_too_many_ids_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = self._get_share_reference() await share.create_share() # Act identifiers = dict() for i in range(0, 6): identifiers['id{}'.format(i)] = AccessPolicy() # Assert with self.assertRaises(ValueError) as e: await share.set_share_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.' ) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_directories_and_files_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = await self._create_share() dir0 = share.get_directory_client() await dir0.upload_file('file1', 'data1') dir1 = share.get_directory_client('dir1') await dir1.create_directory() await dir1.upload_file('file2', 'data2') dir2 = share.get_directory_client('dir2') await dir2.create_directory() # Act resp = [] async for d in share.list_directories_and_files(): resp.append(d) # Assert self.assertIsNotNone(resp) self.assertEqual(len(resp), 3) self.assertIsNotNone(resp[0]) self.assertNamedItemInContainer(resp, 'dir1') self.assertNamedItemInContainer(resp, 'dir2') self.assertNamedItemInContainer(resp, 'file1') await self._delete_shares(share) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_directories_and_files_with_snapshot_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share_name = await self._create_share() dir1 = share_name.get_directory_client('dir1') await dir1.create_directory() dir2 = share_name.get_directory_client('dir2') await dir2.create_directory() snapshot1 = await share_name.create_snapshot() dir3 = share_name.get_directory_client('dir3') await dir3.create_directory() file1 = share_name.get_file_client('file1') await file1.upload_file('data') # Act snapshot_client = self.fsc.get_share_client(share_name.share_name, snapshot=snapshot1) resp = [] async for d in snapshot_client.list_directories_and_files(): resp.append(d) # Assert self.assertIsNotNone(resp) self.assertEqual(len(resp), 2) self.assertIsNotNone(resp[0]) self.assertNamedItemInContainer(resp, 'dir1') self.assertNamedItemInContainer(resp, 'dir2') await self._delete_shares(share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_directories_and_files_with_num_results_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share_name = await self._create_share() dir1 = await share_name.create_directory('dir1') root = share_name.get_directory_client() await root.upload_file('filea1', '1024') await root.upload_file('filea2', '1024') await root.upload_file('filea3', '1024') await root.upload_file('fileb1', '1024') # Act result = share_name.list_directories_and_files( results_per_page=2).by_page() results = [] async for r in await result.__anext__(): results.append(r) # Assert self.assertIsNotNone(result) self.assertEqual(len(results), 2) self.assertNamedItemInContainer(results, 'dir1') self.assertNamedItemInContainer(results, 'filea1') await self._delete_shares(share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_directories_and_files_with_num_results_and_marker_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share_name = await self._create_share() dir1 = share_name.get_directory_client('dir1') await dir1.create_directory() await dir1.upload_file('filea1', '1024') await dir1.upload_file('filea2', '1024') await dir1.upload_file('filea3', '1024') await dir1.upload_file('fileb1', '1024') # Act generator1 = share_name.list_directories_and_files( 'dir1', results_per_page=2).by_page() result1 = [] async for r in await generator1.__anext__(): result1.append(r) generator2 = share_name.list_directories_and_files( 'dir1', results_per_page=2).by_page( continuation_token=generator1.continuation_token) result2 = [] async for r in await generator2.__anext__(): result2.append(r) # Assert self.assertEqual(len(result1), 2) self.assertEqual(len(result2), 2) self.assertNamedItemInContainer(result1, 'filea1') self.assertNamedItemInContainer(result1, 'filea2') self.assertNamedItemInContainer(result2, 'filea3') self.assertNamedItemInContainer(result2, 'fileb1') self.assertEqual(generator2.continuation_token, None) await self._delete_shares(share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_directories_and_files_with_prefix_async( self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = await self._create_share() dir1 = await share.create_directory('dir1') await share.create_directory('dir1/pref_dir3') await share.create_directory('dir2') root = share.get_directory_client() await root.upload_file('file1', '1024') await dir1.upload_file('pref_file2', '1025') await dir1.upload_file('file3', '1025') # Act resp = [] async for d in share.list_directories_and_files( 'dir1', name_starts_with='pref'): resp.append(d) # Assert self.assertIsNotNone(resp) self.assertEqual(len(resp), 2) self.assertIsNotNone(resp[0]) self.assertNamedItemInContainer(resp, 'pref_file2') self.assertNamedItemInContainer(resp, 'pref_dir3') await self._delete_shares(share) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_shared_access_share_async(self, resource_group, location, storage_account, storage_account_key): # SAS URL is calculated from storage key, so this test runs live only if not self.is_live: return self._setup(storage_account, storage_account_key) file_name = 'file1' dir_name = 'dir1' data = b'hello world' share = await self._create_share() dir1 = await share.create_directory(dir_name) await dir1.upload_file(file_name, data) token = generate_share_sas( share.account_name, share.share_name, share.credential.account_key, expiry=datetime.utcnow() + timedelta(hours=1), permission=ShareSasPermissions(read=True), ) sas_client = ShareFileClient( self.account_url(storage_account, "file"), share_name=share.share_name, file_path=dir_name + '/' + file_name, credential=token, ) # Act response = requests.get(sas_client.url) # Assert self.assertTrue(response.ok) self.assertEqual(data, response.content) await self._delete_shares(share.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_permission_for_share(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) user_given_permission = "O:S-1-5-21-2127521184-1604012920-1887927527-21560751G:S-1-5-21-2127521184-" \ "1604012920-1887927527-513D:AI(A;;FA;;;SY)(A;;FA;;;BA)(A;;0x1200a9;;;" \ "S-1-5-21-397955417-626881126-188441444-3053964)" share_client = await self._create_share() permission_key = await share_client.create_permission_for_share( user_given_permission) self.assertIsNotNone(permission_key) server_returned_permission = await share_client.get_permission_for_share( permission_key) self.assertIsNotNone(server_returned_permission) permission_key2 = await share_client.create_permission_for_share( server_returned_permission) # the permission key obtained from user_given_permission should be the same as the permission key obtained from # server returned permission self.assertEqual(permission_key, permission_key2) await self._delete_shares(share_client.share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_transport_closed_only_once_async(self, resource_group, location, storage_account, storage_account_key): if not self.is_live: return self._setup(storage_account, storage_account_key) transport = AioHttpTransport() url = self.account_url(storage_account, "file") credential = storage_account_key prefix = TEST_SHARE_PREFIX share_name = self.get_resource_name(prefix) async with ShareServiceClient(url, credential=credential, transport=transport) as fsc: await fsc.get_service_properties() assert transport.session is not None async with fsc.get_share_client(share_name) as fc: assert transport.session is not None await fsc.get_service_properties() assert transport.session is not None await self._delete_shares(share_name) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_directory_from_share_async(self, resource_group, location, storage_account, storage_account_key): self._setup(storage_account, storage_account_key) share = await self._create_share() await share.create_directory('dir1') await share.create_directory('dir2') await share.create_directory('dir3') # Act resp = [] async for d in share.list_directories_and_files(): resp.append(d) self.assertEqual(len(resp), 3) await share.delete_directory('dir3') # Assert resp = [] async for d in share.list_directories_and_files(): resp.append(d) self.assertEqual(len(resp), 2) await self._delete_shares(share.share_name)
def _setup(self, storage_account, storage_account_key): url = self.account_url(storage_account, "file") credential = storage_account_key self.fsc = ShareServiceClient(url, credential=credential, transport=AiohttpTestTransport())
class StorageDirectoryTest(AsyncStorageTestCase): # --Helpers----------------------------------------------------------------- async def _setup(self, storage_account, storage_account_key): url = self.get_file_url(storage_account.name) credential = storage_account_key self.fsc = ShareServiceClient(url, credential=credential, transport=AiohttpTestTransport()) self.share_name = self.get_resource_name('utshare') if not self.is_playback(): try: await self.fsc.create_share(self.share_name) except: pass def _teardown(self, FILE_PATH): if os.path.isfile(FILE_PATH): try: os.remove(FILE_PATH) except: pass # --Test cases for directories ---------------------------------------------- @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_directories_async(self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) # Act created = await share_client.create_directory('dir1') # Assert self.assertTrue(created) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_directories_with_metadata_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) metadata = {'hello': 'world', 'number': '42'} # Act directory = await share_client.create_directory('dir1', metadata=metadata) # Assert props = await directory.get_directory_properties() self.assertDictEqual(props.metadata, metadata) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_directories_fail_on_exist_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) # Act created = await share_client.create_directory('dir1') with self.assertRaises(ResourceExistsError): await share_client.create_directory('dir1') # Assert self.assertTrue(created) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_subdirectories_async(self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') # Act created = await directory.create_subdirectory('dir2') # Assert self.assertTrue(created) self.assertEqual(created.directory_path, 'dir1/dir2') @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_subdirectories_with_metadata_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') metadata = {'hello': 'world', 'number': '42'} # Act created = await directory.create_subdirectory('dir2', metadata=metadata) # Assert self.assertTrue(created) self.assertEqual(created.directory_path, 'dir1/dir2') properties = await created.get_directory_properties() self.assertEqual(properties.metadata, metadata) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_create_file_in_directory_async(self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) file_data = b'12345678' * 1024 file_name = self.get_resource_name('file') share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') # Act new_file = await directory.upload_file(file_name, file_data) # Assert file_content = await new_file.download_file() file_content = await file_content.readall() self.assertEqual(file_content, file_data) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_file_in_directory_async(self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) file_name = self.get_resource_name('file') share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') new_file = await directory.upload_file(file_name, "hello world") # Act deleted = await directory.delete_file(file_name) # Assert self.assertIsNone(deleted) with self.assertRaises(ResourceNotFoundError): await new_file.get_file_properties() @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_subdirectories_async(self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') await directory.create_subdirectory('dir2') # Act deleted = await directory.delete_subdirectory('dir2') # Assert self.assertIsNone(deleted) subdir = directory.get_subdirectory_client('dir2') with self.assertRaises(ResourceNotFoundError): await subdir.get_directory_properties() @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_directory_properties_async(self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') # Act props = await directory.get_directory_properties() # Assert self.assertIsNotNone(props) self.assertIsNotNone(props.etag) self.assertIsNotNone(props.last_modified) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_directory_properties_with_snapshot_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) metadata = {"test1": "foo", "test2": "bar"} directory = await share_client.create_directory('dir1', metadata=metadata) snapshot1 = await share_client.create_snapshot() metadata2 = {"test100": "foo100", "test200": "bar200"} await directory.set_directory_metadata(metadata2) # Act share_client = self.fsc.get_share_client(self.share_name, snapshot=snapshot1) snap_dir = share_client.get_directory_client('dir1') props = await snap_dir.get_directory_properties() # Assert self.assertIsNotNone(props) self.assertIsNotNone(props.etag) self.assertIsNotNone(props.last_modified) self.assertDictEqual(metadata, props.metadata) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_directory_metadata_with_snapshot_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) metadata = {"test1": "foo", "test2": "bar"} directory = await share_client.create_directory('dir1', metadata=metadata) snapshot1 = await share_client.create_snapshot() metadata2 = {"test100": "foo100", "test200": "bar200"} await directory.set_directory_metadata(metadata2) # Act share_client = self.fsc.get_share_client(self.share_name, snapshot=snapshot1) snap_dir = share_client.get_directory_client('dir1') snapshot_props = await snap_dir.get_directory_properties() # Assert self.assertIsNotNone(snapshot_props.metadata) self.assertDictEqual(metadata, snapshot_props.metadata) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_directory_properties_with_non_existing_directory_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = share_client.get_directory_client('dir1') # Act with self.assertRaises(ResourceNotFoundError): await directory.get_directory_properties() # Assert @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_directory_exists_async(self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') # Act exists = await directory.get_directory_properties() # Assert self.assertTrue(exists) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_directory_not_exists_async(self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = share_client.get_directory_client('dir1') # Act with self.assertRaises(ResourceNotFoundError): await directory.get_directory_properties() # Assert @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_directory_parent_not_exists_async(self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = share_client.get_directory_client('missing1/missing2') # Act with self.assertRaises(ResourceNotFoundError) as e: await directory.get_directory_properties() # Assert self.assertEqual(e.exception.error_code, StorageErrorCode.parent_not_found) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_directory_exists_with_snapshot_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') snapshot = await share_client.create_snapshot() await directory.delete_directory() # Act share_client = self.fsc.get_share_client(self.share_name, snapshot=snapshot) snap_dir = share_client.get_directory_client('dir1') exists = await snap_dir.get_directory_properties() # Assert self.assertTrue(exists) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_directory_not_exists_with_snapshot_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) snapshot = await share_client.create_snapshot() directory = await share_client.create_directory('dir1') # Act share_client = self.fsc.get_share_client(self.share_name, snapshot=snapshot) snap_dir = share_client.get_directory_client('dir1') with self.assertRaises(ResourceNotFoundError): await snap_dir.get_directory_properties() # Assert @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_set_directory_metadata_async(self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') metadata = {'hello': 'world', 'number': '43'} # Act await directory.set_directory_metadata(metadata) props = await directory.get_directory_properties() # Assert self.assertDictEqual(props.metadata, metadata) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_set_directory_properties_with_empty_smb_properties( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory_client = await share_client.create_directory('dir1') directory_properties_on_creation = await directory_client.get_directory_properties( ) # Act await directory_client.set_http_headers() directory_properties = await directory_client.get_directory_properties( ) # Assert # Make sure set empty smb_properties doesn't change smb_properties self.assertEqual(directory_properties_on_creation.creation_time, directory_properties.creation_time) self.assertEqual(directory_properties_on_creation.last_write_time, directory_properties.last_write_time) self.assertEqual(directory_properties_on_creation.permission_key, directory_properties.permission_key) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_set_directory_properties_with_file_permission_key( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory_client = await share_client.create_directory('dir1') directory_properties_on_creation = await directory_client.get_directory_properties( ) permission_key = directory_properties_on_creation.permission_key last_write_time = directory_properties_on_creation.last_write_time creation_time = directory_properties_on_creation.creation_time new_last_write_time = last_write_time + timedelta(hours=1) new_creation_time = creation_time + timedelta(hours=1) # Act await directory_client.set_http_headers( file_attributes='None', file_creation_time=new_creation_time, file_last_write_time=new_last_write_time, permission_key=permission_key) directory_properties = await directory_client.get_directory_properties( ) # Assert self.assertIsNotNone(directory_properties) self.assertEqual(directory_properties.creation_time, new_creation_time) self.assertEqual(directory_properties.last_write_time, new_last_write_time) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_subdirectories_and_files_async(self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') await asyncio.gather(directory.create_subdirectory("subdir1"), directory.create_subdirectory("subdir2"), directory.create_subdirectory("subdir3"), directory.upload_file("file1", "data1"), directory.upload_file("file2", "data2"), directory.upload_file("file3", "data3")) # Act list_dir = [] async for d in directory.list_directories_and_files(): list_dir.append(d) # Assert expected = [ { 'name': 'subdir1', 'is_directory': True }, { 'name': 'subdir2', 'is_directory': True }, { 'name': 'subdir3', 'is_directory': True }, { 'name': 'file1', 'is_directory': False, 'size': 5 }, { 'name': 'file2', 'is_directory': False, 'size': 5 }, { 'name': 'file3', 'is_directory': False, 'size': 5 }, ] self.assertEqual(len(list_dir), 6) self.assertEqual(list_dir, expected) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_subdirectories_and_files_with_prefix_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') await asyncio.gather(directory.create_subdirectory("subdir1"), directory.create_subdirectory("subdir2"), directory.create_subdirectory("subdir3"), directory.upload_file("file1", "data1"), directory.upload_file("file2", "data2"), directory.upload_file("file3", "data3")) # Act list_dir = [] async for d in directory.list_directories_and_files( name_starts_with="sub"): list_dir.append(d) # Assert expected = [ { 'name': 'subdir1', 'is_directory': True }, { 'name': 'subdir2', 'is_directory': True }, { 'name': 'subdir3', 'is_directory': True }, ] self.assertEqual(len(list_dir), 3) self.assertEqual(list_dir, expected) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_subdirectories_and_files_with_snapshot_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') await asyncio.gather(directory.create_subdirectory("subdir1"), directory.create_subdirectory("subdir2"), directory.upload_file("file1", "data1")) snapshot = await share_client.create_snapshot() await asyncio.gather(directory.create_subdirectory("subdir3"), directory.upload_file("file2", "data2"), directory.upload_file("file3", "data3")) share_client = self.fsc.get_share_client(self.share_name, snapshot=snapshot) snapshot_dir = share_client.get_directory_client('dir1') # Act list_dir = [] async for d in snapshot_dir.list_directories_and_files(): list_dir.append(d) # Assert expected = [ { 'name': 'subdir1', 'is_directory': True }, { 'name': 'subdir2', 'is_directory': True }, { 'name': 'file1', 'is_directory': False, 'size': 5 }, ] self.assertEqual(len(list_dir), 3) self.assertEqual(list_dir, expected) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_list_nested_subdirectories_and_files_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') subdir = await directory.create_subdirectory("subdir1") await subdir.create_subdirectory("subdir2") await subdir.create_subdirectory("subdir3") await asyncio.gather(directory.upload_file("file1", "data1"), subdir.upload_file("file2", "data2"), subdir.upload_file("file3", "data3")) # Act list_dir = [] async for d in directory.list_directories_and_files(): list_dir.append(d) # Assert expected = [ { 'name': 'subdir1', 'is_directory': True }, { 'name': 'file1', 'is_directory': False, 'size': 5 }, ] self.assertEqual(len(list_dir), 2) self.assertEqual(list_dir, expected) @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_directory_with_existing_share_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') # Act deleted = await directory.delete_directory() # Assert self.assertIsNone(deleted) with self.assertRaises(ResourceNotFoundError): await directory.get_directory_properties() @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_delete_directory_with_non_existing_directory_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = share_client.get_directory_client('dir1') # Act with self.assertRaises(ResourceNotFoundError): await directory.delete_directory() # Assert @GlobalStorageAccountPreparer() @AsyncStorageTestCase.await_prepared_test async def test_get_directory_properties_server_encryption_async( self, resource_group, location, storage_account, storage_account_key): # Arrange await self._setup(storage_account, storage_account_key) share_client = self.fsc.get_share_client(self.share_name) directory = await share_client.create_directory('dir1') # Act props = await directory.get_directory_properties() # Assert self.assertIsNotNone(props) self.assertIsNotNone(props.etag) self.assertIsNotNone(props.last_modified) if self.is_file_encryption_enabled(): self.assertTrue(props.server_encrypted) else: self.assertFalse(props.server_encrypted)
class StorageHandleTest(AsyncStorageTestCase): def _setup(self, storage_account, storage_account_key): file_url = self.account_url(storage_account_name, "file") credentials = storage_account_key self.fsc = ShareServiceClient(account_url=file_url, credential=credentials, transport=AiohttpTestTransport()) self.test_shares = [] # --Helpers----------------------------------------------------------------- def _validate_handles(self, handles): # Assert self.assertIsNotNone(handles) self.assertGreaterEqual(len(handles), 1) self.assertIsNotNone(handles[0]) # verify basic fields # path may or may not be present # last_connect_time_string has been missing in the test self.assertIsNotNone(handles[0].id) self.assertIsNotNone(handles[0].file_id) self.assertIsNotNone(handles[0].parent_id) self.assertIsNotNone(handles[0].session_id) self.assertIsNotNone(handles[0].client_ip) self.assertIsNotNone(handles[0].open_time) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_close_single_handle_async(self, storage_account_name, storage_account_key): pytest.skip("investigate later") # don't run live, since the test set up was highly manual # only run when recording, or playing back in CI if self.is_live: pytest.skip("Cannot run in live without manual setup") self._setup(storage_account_name, storage_account_key) share = self.fsc.get_share_client(TEST_SHARE_NAME) root = share.get_directory_client() handles = [] async for handle in root.list_handles(recursive=True): handles.append(handle) self._validate_handles(handles) # Act with self.assertRaises(ValueError): await root.close_handle('*') handles_info = await root.close_handle(handles[0]) # Assert 1 handle has been closed self.assertEqual(1, handles_info['closed_handles_count']) self.assertEqual(handles_info['failed_handles_count'], 0) @FileSharePreparer() @AsyncStorageTestCase.await_prepared_test async def test_close_all_handle_async(self, storage_account_name, storage_account_key): pytest.skip("investigate later") # don't run live, since the test set up was highly manual # only run when recording, or playing back in CI if self.is_live: pytest.skip("Cannot run in live without manual setup") self._setup(storage_account_name, storage_account_key) share = self.fsc.get_share_client(TEST_SHARE_NAME) root = share.get_directory_client() handles = [] async for handle in root.list_handles(recursive=True): handles.append(handle) self._validate_handles(handles) # Act handles_info = await root.close_all_handles(recursive=True) # Assert at least 1 handle has been closed self.assertTrue(handles_info['closed_handles_count'] > 1) self.assertEqual(handles_info['failed_handles_count'], 0)