def test_set_table_acl_with_signed_identifiers(self, resource_group,
location, storage_account,
storage_account_key):
# Arrange
url = self.account_url(storage_account, "table")
if 'cosmos' in url:
pytest.skip("Cosmos endpoint does not support this")
ts = TableServiceClient(url, storage_account_key)
table = self._create_table(ts)
client = ts.get_table_client(table_name=table.table_name)
# Act
identifiers = dict()
identifiers['testid'] = AccessPolicy(
start=datetime.utcnow() - timedelta(minutes=5),
expiry=datetime.utcnow() + timedelta(hours=1),
permission='r')
try:
client.set_table_access_policy(signed_identifiers=identifiers)
# Assert
acl = client.get_table_access_policy()
self.assertIsNotNone(acl)
self.assertEqual(len(acl), 1)
self.assertTrue('testid' in acl)
finally:
# self._delete_table(table)
ts.delete_table(table.table_name)
def test_aad_query_list_tables(self, tables_storage_account_name):
try:
account_url = self.account_url(tables_storage_account_name,
"table")
ts = TableServiceClient(credential=self.get_token_credential(),
endpoint=account_url)
table_name1 = self._get_table_reference(prefix="table1")
table_name2 = self._get_table_reference(prefix="table2")
table_name3 = self._get_table_reference(prefix="table3")
table_name4 = self._get_table_reference(prefix="table4")
ts.create_table(table_name1)
ts.create_table(table_name2)
ts.create_table(table_name3)
ts.create_table(table_name4)
count = 0
for table in ts.list_tables():
count += 1
assert count == 4
query_filter = "TableName eq '{}'".format(table_name2)
count = 0
for table in ts.query_tables(query_filter):
count += 1
assert table.name == table_name2
assert count == 1
finally:
for table in ts.list_tables():
ts.delete_table(table.name)
def test_create_properties(self, tables_storage_account_name, tables_primary_storage_account_key):
# # Arrange
account_url = self.account_url(tables_storage_account_name, "table")
ts = TableServiceClient(credential=tables_primary_storage_account_key, endpoint=account_url)
table_name = self._get_table_reference()
# Act
created = ts.create_table(table_name)
# Assert
assert created.table_name == table_name
properties = ts.get_service_properties()
ts.set_service_properties(analytics_logging=TableAnalyticsLogging(write=True))
# have to wait for return to service
p = ts.get_service_properties()
# have to wait for return to service
ts.set_service_properties(
minute_metrics=TableMetrics(
enabled=True,
include_apis=True,
retention_policy=TableRetentionPolicy(enabled=True, days=5)
)
)
ps = ts.get_service_properties()
ts.delete_table(table_name)
def test_set_table_acl_with_signed_identifiers(self, tables_storage_account_name, tables_primary_storage_account_key):
# Arrange
account_url = self.account_url(tables_storage_account_name, "table")
ts = TableServiceClient(credential=tables_primary_storage_account_key, endpoint=account_url)
table = self._create_table(ts)
client = ts.get_table_client(table_name=table.table_name)
# Act
start = datetime(2021, 6, 8, 2, 10, 9) - timedelta(minutes=5)
expiry = datetime(2021, 6, 8, 2, 10, 9) + timedelta(hours=1)
identifiers = {'testid': TableAccessPolicy(start=start, expiry=expiry, permission='r')}
try:
client.set_table_access_policy(signed_identifiers=identifiers)
# Assert
acl = client.get_table_access_policy()
assert acl is not None
assert len(acl) == 1
assert acl.get('testid')
self._assert_policy_datetime(start, acl['testid'].start)
self._assert_policy_datetime(expiry, acl['testid'].expiry)
assert acl['testid'].permission == 'r'
finally:
ts.delete_table(table.table_name)
def test_set_table_acl_with_empty_signed_identifier(
self, resource_group, location, cosmos_account,
cosmos_account_key):
# Arrange
url = self.account_url(cosmos_account, "cosmos")
if 'cosmos' in url:
pytest.skip("Cosmos endpoint does not support this")
ts = TableServiceClient(url, cosmos_account_key)
table = self._create_table(ts)
try:
# Act
table.set_table_access_policy(signed_identifiers={'empty': None})
# Assert
acl = table.get_table_access_policy()
self.assertIsNotNone(acl)
self.assertEqual(len(acl), 1)
self.assertIsNotNone(acl['empty'])
self.assertIsNone(acl['empty'].permission)
self.assertIsNone(acl['empty'].expiry)
self.assertIsNone(acl['empty'].start)
finally:
ts.delete_table(table.table_name)
if self.is_live:
sleep(SLEEP_DELAY)
def test_create_properties(self, resource_group, location, storage_account,
storage_account_key):
# # Arrange
ts = TableServiceClient(self.account_url(storage_account, "table"),
storage_account_key)
table_name = self._get_table_reference()
# Act
created = ts.create_table(table_name)
# Assert
assert created.table_name == table_name
properties = ts.get_service_properties()
print(properties)
ts.set_service_properties(analytics_logging=TableAnalyticsLogging(
write=True))
# have to wait for return to service
p = ts.get_service_properties()
# have to wait for return to service
ts.set_service_properties(minute_metrics=Metrics(
enabled=True,
include_apis=True,
retention_policy=RetentionPolicy(enabled=True, days=5)))
ps = ts.get_service_properties()
print(ps)
print(p)
ts.delete_table(table_name)
def test_locale(self, tables_cosmos_account_name,
tables_primary_cosmos_account_key):
# Arrange
ts = TableServiceClient(
self.account_url(tables_cosmos_account_name, "cosmos"),
tables_primary_cosmos_account_key)
table = (self._get_table_reference())
init_locale = locale.getlocale()
if os.name == "nt":
culture = "Spanish_Spain"
elif os.name == 'posix':
culture = 'es_ES.UTF-8'
else:
culture = 'es_ES.utf8'
locale.setlocale(locale.LC_ALL, culture)
e = None
# Act
ts.create_table(table)
resp = ts.list_tables()
e = sys.exc_info()[0]
# Assert
assert e is None
ts.delete_table(table)
locale.setlocale(locale.LC_ALL, init_locale[0] or 'en_US')
if self.is_live:
sleep(SLEEP_DELAY)
def test_set_table_acl_with_signed_identifiers(self, resource_group, location, cosmos_account,
cosmos_account_key):
# Arrange
url = self.account_url(cosmos_account, "cosmos")
if 'cosmos' in url:
pytest.skip("Cosmos endpoint does not support this")
ts = TableServiceClient(url, cosmos_account_key)
table = self._create_table(ts)
client = ts.get_table_client(table_name=table.table_name)
# Act
identifiers = dict()
identifiers['testid'] = AccessPolicy(start=datetime.utcnow() - timedelta(minutes=5),
expiry=datetime.utcnow() + timedelta(hours=1),
permission='r')
try:
client.set_table_access_policy(signed_identifiers=identifiers)
# Assert
acl = client.get_table_access_policy()
assert acl is not None
assert len(acl) == 1
assert 'testid' in acl
finally:
ts.delete_table(table.table_name)
if self.is_live:
sleep(SLEEP_DELAY)
def test_create_properties(self, tables_cosmos_account_name,
tables_primary_cosmos_account_key):
# # Arrange
ts = TableServiceClient(
self.account_url(tables_cosmos_account_name, "cosmos"),
tables_primary_cosmos_account_key)
table_name = self._get_table_reference()
# Act
created = ts.create_table(table_name)
# Assert
assert created.table_name == table_name
# properties = ts.get_service_properties()
ts.set_service_properties(analytics_logging=TableAnalyticsLogging(
write=True))
p = ts.get_service_properties()
ts.set_service_properties(minute_metrics=Metrics(
enabled=True,
include_apis=True,
retention_policy=RetentionPolicy(enabled=True, days=5)))
ps = ts.get_service_properties()
ts.delete_table(table_name)
if self.is_live:
sleep(SLEEP_DELAY)
def test_set_table_acl_with_signed_identifiers(
self, tables_cosmos_account_name,
tables_primary_cosmos_account_key):
# Arrange
url = self.account_url(tables_cosmos_account_name, "cosmos")
ts = TableServiceClient(url, tables_primary_cosmos_account_key)
table = self._create_table(ts)
client = ts.get_table_client(table_name=table.table_name)
# Act
identifiers = dict()
identifiers['testid'] = AccessPolicy(
start=datetime.utcnow() - timedelta(minutes=5),
expiry=datetime.utcnow() + timedelta(hours=1),
permission='r')
try:
client.set_table_access_policy(signed_identifiers=identifiers)
# Assert
acl = client.get_table_access_policy()
assert acl is not None
assert len(acl) == 1
assert 'testid' in acl
finally:
ts.delete_table(table.table_name)
if self.is_live:
sleep(SLEEP_DELAY)
def test_locale(self, resource_group, location, storage_account,
storage_account_key):
# Arrange
ts = TableServiceClient(self.account_url(storage_account, "table"),
storage_account_key)
table = (self._get_table_reference())
init_locale = locale.getlocale()
if os.name == "nt":
culture = "Spanish_Spain"
elif os.name == 'posix':
culture = 'es_ES.UTF-8'
else:
culture = 'es_ES.utf8'
try:
locale.setlocale(locale.LC_ALL, culture)
e = None
# Act
table.create_table()
try:
resp = ts.query_tables()
except:
e = sys.exc_info()[0]
# Assert
self.assertIsNone(e)
finally:
ts.delete_table(table.table_name)
locale.setlocale(locale.LC_ALL, init_locale[0] or 'en_US')
def test_delete_table_with_non_existing_table_fail_not_exist(
self, tables_cosmos_account_name,
tables_primary_cosmos_account_key):
# Arrange
ts = TableServiceClient(self.account_url(tables_cosmos_account_name,
"cosmos"),
credential=tables_primary_cosmos_account_key)
table_name = self._get_table_reference()
ts.delete_table(table_name)
def test_create_table_if_exists_new_table(self, resource_group, location, storage_account, storage_account_key):
ts = TableServiceClient(self.account_url(storage_account, "table"), storage_account_key)
table_name = self._get_table_reference()
t = ts.create_table_if_not_exists(table_name)
self.assertIsNotNone(t)
self.assertEqual(t.table_name, table_name)
ts.delete_table(table_name)
def test_delete_table_with_non_existing_table_fail_not_exist(
self, tables_storage_account_name,
tables_primary_storage_account_key):
# Arrange
account_url = self.account_url(tables_storage_account_name, "table")
ts = TableServiceClient(credential=tables_primary_storage_account_key,
endpoint=account_url)
table_name = self._get_table_reference()
ts.delete_table(table_name)
def test_delete_table_with_non_existing_table_fail_not_exist(self, resource_group, location, storage_account,
storage_account_key):
# Arrange
ts = TableServiceClient(self.account_url(storage_account, "table"), storage_account_key)
table_name = self._get_table_reference()
# Act
with self.assertRaises(HttpResponseError):
ts.delete_table(table_name)
def delete_table(self):
from azure.data.tables import TableServiceClient
from azure.core.exceptions import ResourceNotFoundError
table_service_client = TableServiceClient(account_url=self.account_url,
credential=self.access_key)
try:
table_service_client.delete_table(table_name=self.table_name)
except ResourceNotFoundError:
print("TableNotFound")
def test_create_table_if_exists_new_table(self, tables_storage_account_name, tables_primary_storage_account_key):
account_url = self.account_url(tables_storage_account_name, "table")
ts = TableServiceClient(credential=tables_primary_storage_account_key, endpoint=account_url)
table_name = self._get_table_reference()
t = ts.create_table_if_not_exists(table_name)
assert t is not None
assert t.table_name == table_name
ts.delete_table(table_name)
def test_delete_table_invalid_name(self):
# Arrange
account_url = self.account_url(self.tables_storage_account_name, "table")
tsc = TableServiceClient(account_url, credential=self.credential)
invalid_table_name = "my_table"
with pytest.raises(ValueError) as excinfo:
tsc.delete_table(invalid_table_name)
assert "Table names must be alphanumeric, cannot begin with a number, and must be between 3-63 characters long.""" in str(
excinfo)
def test_delete_table_with_non_existing_table_fail_not_exist(
self, tables_cosmos_account_name,
tables_primary_cosmos_account_key):
# Arrange
ts = TableServiceClient(
self.account_url(tables_cosmos_account_name, "cosmos"),
tables_primary_cosmos_account_key)
table_name = self._get_table_reference()
ts.delete_table(table_name)
if self.is_live:
sleep(SLEEP_DELAY)
def test_delete_table_with_non_existing_table_fail_not_exist(self, resource_group, location, cosmos_account,
cosmos_account_key):
# Arrange
ts = TableServiceClient(self.account_url(cosmos_account, "cosmos"), cosmos_account_key)
table_name = self._get_table_reference()
# Act
with self.assertRaises(HttpResponseError):
ts.delete_table(table_name)
if self.is_live:
sleep(SLEEP_DELAY)
def test_set_table_acl_with_empty_signed_identifier(
self, tables_storage_account_name,
tables_primary_storage_account_key):
# Arrange
account_url = self.account_url(tables_storage_account_name, "table")
ts = TableServiceClient(credential=tables_primary_storage_account_key,
endpoint=account_url)
table = self._create_table(ts)
try:
dt = datetime(2021, 6, 8, 2, 10, 9)
signed_identifiers = {
'null':
None,
'empty':
TableAccessPolicy(start=None, expiry=None, permission=None),
'partial':
TableAccessPolicy(permission='r'),
'full':
TableAccessPolicy(start=dt, expiry=dt, permission='r')
}
table.set_table_access_policy(signed_identifiers)
acl = table.get_table_access_policy()
assert acl is not None
assert len(acl) == 4
assert acl['null'] is None
assert acl['empty'] is None
assert acl['partial'] is not None
assert acl['partial'].permission == 'r'
assert acl['partial'].expiry is None
assert acl['partial'].start is None
assert acl['full'] is not None
assert acl['full'].permission == 'r'
self._assert_policy_datetime(dt, acl['full'].expiry)
self._assert_policy_datetime(dt, acl['full'].start)
signed_identifiers.pop('empty')
signed_identifiers['partial'] = None
table.set_table_access_policy(signed_identifiers)
acl = table.get_table_access_policy()
assert acl is not None
assert len(acl) == 3
assert 'empty' not in acl
assert acl['null'] is None
assert acl['partial'] is None
assert acl['full'] is not None
assert acl['full'].permission == 'r'
self._assert_policy_datetime(dt, acl['full'].expiry)
self._assert_policy_datetime(dt, acl['full'].start)
finally:
ts.delete_table(table.table_name)
def test_create_table(self, resource_group, location, storage_account, storage_account_key):
# # Arrange
ts = TableServiceClient(self.account_url(storage_account, "table"), storage_account_key)
table_name = self._get_table_reference()
# Act
created = ts.create_table(table_name)
# Assert
assert created.table_name == table_name
ts.delete_table(table_name)
def test_create_table_unicode_name(self, tables_cosmos_account_name,
tables_primary_cosmos_account_key):
# Arrange
ts = TableServiceClient(self.account_url(tables_cosmos_account_name,
"cosmos"),
credential=tables_primary_cosmos_account_key)
table_name = u'啊齄丂狛狜'
client = ts.create_table(table_name)
assert client.table_name == table_name
ts.delete_table(table_name)
def test_query_tables_with_filter(self, resource_group, location, storage_account, storage_account_key):
# Arrange
ts = TableServiceClient(self.account_url(storage_account, "table"), storage_account_key)
table = self._create_table(ts)
# Act
name_filter = "TableName eq '{}'".format(table.table_name)
tables = list(ts.query_tables(filter=name_filter))
# Assert
self.assertIsNotNone(tables)
self.assertEqual(len(tables), 1)
# self.assertEqual(tables[0].table_name, [table.table_name])
# table.delete_table()
ts.delete_table(table.table_name)
def test_query_tables(self, resource_group, location, storage_account, storage_account_key):
# Arrange
ts = TableServiceClient(self.account_url(storage_account, "table"), storage_account_key)
table = self._create_table(ts)
# Act
tables = list(ts.list_tables())
# Assert
self.assertIsNotNone(tables)
self.assertGreaterEqual(len(tables), 1)
self.assertIsNotNone(tables[0])
# self.assertNamedItemInContainer(tables, table.table_name)
ts.delete_table(table.table_name)
def test_create_table(self, tables_storage_account_name, tables_primary_storage_account_key):
# # Arrange
account_url = self.account_url(tables_storage_account_name, "table")
ts = TableServiceClient(credential=tables_primary_storage_account_key, endpoint=account_url)
table_name = self._get_table_reference()
# Act
table = ts.get_table_client(table_name)
created = table.create_table()
# Assert
assert created.name == table_name
ts.delete_table(table_name)
def test_get_table_acl(self, tables_storage_account_name, tables_primary_storage_account_key):
# Arrange
url = self.account_url(tables_storage_account_name, "table")
account_url = self.account_url(tables_storage_account_name, "table")
ts = TableServiceClient(credential=tables_primary_storage_account_key, endpoint=account_url)
table = self._create_table(ts)
try:
# Act
acl = table.get_table_access_policy()
# Assert
assert acl is not None
assert len(acl) == 0
finally:
ts.delete_table(table.table_name)
def test_create_table(self, resource_group, location, cosmos_account, cosmos_account_key):
# # Arrange
ts = TableServiceClient(self.account_url(cosmos_account, "cosmos"), cosmos_account_key)
table_name = self._get_table_reference()
# Act
created = ts.create_table(table_name)
# Assert
assert created.table_name == table_name
ts.delete_table(table_name)
if self.is_live:
sleep(SLEEP_DELAY)
def test_create_table(self, tables_cosmos_account_name, tables_primary_cosmos_account_key):
# # Arrange
ts = TableServiceClient(self.account_url(tables_cosmos_account_name, "cosmos"), tables_primary_cosmos_account_key)
table_name = self._get_table_reference()
# Act
created = ts.create_table(table_name)
# Assert
assert created.table_name == table_name
ts.delete_table(table_name)
if self.is_live:
sleep(SLEEP_DELAY)
def test_query_tables(self, tables_cosmos_account_name, tables_primary_cosmos_account_key):
# Arrange
ts = TableServiceClient(self.account_url(tables_cosmos_account_name, "cosmos"), tables_primary_cosmos_account_key)
table = self._create_table(ts)
# Act
tables = list(ts.list_tables())
# Assert
assert tables is not None
assert len(tables) >= 1
assert tables[0] is not None
ts.delete_table(table.table_name)
if self.is_live:
sleep(SLEEP_DELAY)