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)