async 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")
await ts.create_table(table_name1)
await ts.create_table(table_name2)
await ts.create_table(table_name3)
await ts.create_table(table_name4)
count = 0
async for table in ts.list_tables():
count += 1
assert count == 4
query_filter = "TableName eq '{}'".format(table_name2)
count = 0
async for table in ts.query_tables(query_filter):
count += 1
assert table.name == table_name2
assert count == 1
finally:
async for table in ts.list_tables():
await ts.delete_table(table.name)
async def test_query_tables_per_page(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 = "myasynctable"
for i in range(5):
await ts.create_table(table_name + str(i))
query_filter = "TableName eq 'myasynctable0' or TableName eq 'myasynctable1' or TableName eq 'myasynctable2'"
table_count = 0
page_count = 0
async for table_page in ts.query_tables(query_filter, results_per_page=2).by_page():
temp_count = 0
async for table in table_page:
temp_count += 1
assert temp_count <= 2
page_count += 1
table_count += temp_count
assert page_count == 2
assert table_count == 3
for i in range(5):
await ts.delete_table(table_name + str(i))
async def test_query_tables_per_page(self, tables_cosmos_account_name,
tables_primary_cosmos_account_key):
# Arrange
# account_url = self.account_url(tables_cosmos_account_name, "table")
# ts = self.create_client_from_credential(TableServiceClient, tables_primary_cosmos_account_key, account_url=account_url)
ts = TableServiceClient(
self.account_url(tables_cosmos_account_name, "cosmos"),
tables_primary_cosmos_account_key)
table_name = "myasynctable"
for i in range(5):
await ts.create_table(table_name + str(i))
query_filter = "TableName eq 'myasynctable0' or TableName eq 'myasynctable1' or TableName eq 'myasynctable2'"
table_count = 0
page_count = 0
async for table_page in ts.query_tables(filter=query_filter,
results_per_page=2).by_page():
temp_count = 0
async for table in table_page:
temp_count += 1
assert temp_count <= 2
page_count += 1
table_count += temp_count
assert page_count == 2
assert table_count == 3
for i in range(5):
await ts.delete_table(table_name + str(i))
if self.is_live:
sleep(SLEEP_DELAY)
async def test_delete_table_with_existing_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 = await self._create_table(ts)
# Act
await ts.delete_table(table_name=table.table_name)
existing = ts.query_tables("TableName eq '{}'".format(table.table_name))
tables = []
async for e in existing:
tables.append(e)
assert tables == []
async def test_delete_table_with_existing_table(self, resource_group, location, storage_account,
storage_account_key):
# Arrange
ts = TableServiceClient(self.account_url(storage_account, "table"), storage_account_key)
table = await self._create_table(ts)
# Act
await ts.delete_table(table_name=table.table_name)
existing = ts.query_tables("TableName eq '{}'".format(table.table_name))
tables = []
async for e in existing:
tables.append(e)
self.assertEqual(tables, [])
async def test_create_table_fail_on_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()
# Act
created = await ts.create_table(table_name=table_name)
with pytest.raises(ResourceExistsError):
await ts.create_table(table_name=table_name)
name_filter = "TableName eq '{}'".format(table_name)
existing = ts.query_tables(name_filter)
# Assert
assert isinstance(created, TableClient)
await ts.delete_table(table_name=table_name)
async 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 = await self._create_table(ts)
# Act
name_filter = "TableName eq '{}'".format(table.table_name)
tables = []
async for t in ts.query_tables(filter=name_filter):
tables.append(t)
# Assert
self.assertIsNotNone(tables)
self.assertEqual(len(tables), 1)
# self.assertEqual(tables[0].table_name, [table.table_name])
# table.delete_table()
await ts.delete_table(table.table_name)
async def test_query_tables_with_filter(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 = await self._create_table(ts)
# Act
name_filter = "TableName eq '{}'".format(table.table_name)
tables = []
async for t in ts.query_tables(name_filter):
tables.append(t)
# Assert
assert tables is not None
assert len(tables) == 1
await ts.delete_table(table.table_name)
if self.is_live:
sleep(SLEEP_DELAY)
async def test_create_table_fail_on_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
created = await ts.create_table(table_name=table_name)
with self.assertRaises(ResourceExistsError):
await ts.create_table(table_name=table_name)
name_filter = "TableName eq '{}'".format(table_name)
existing = ts.query_tables(filter=name_filter)
# Assert
self.assertIsInstance(created, TableClient)
# self.assertEqual(len(existing), 1)
# TODO: the AsyncItemPaged does not have a length property, and cannot be used as an iterator
await ts.delete_table(table_name=table_name)
async def test_query_tables_with_filter(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 = await self._create_table(ts)
# Act
name_filter = "TableName eq '{}'".format(table.table_name)
tables = []
async for t in ts.query_tables(name_filter):
tables.append(t)
# Assert
assert tables is not None
assert len(tables) == 1
for table_item in tables:
assert isinstance(table_item, TableItem)
assert table_item.name is not None
await ts.delete_table(table.table_name)
async def test_query_tables_with_filter(self, resource_group, location,
cosmos_account,
cosmos_account_key):
# Arrange
ts = TableServiceClient(self.account_url(cosmos_account, "cosmos"),
cosmos_account_key)
table = await self._create_table(ts)
# Act
name_filter = "TableName eq '{}'".format(table.table_name)
tables = []
async for t in ts.query_tables(filter=name_filter):
tables.append(t)
# Assert
self.assertIsNotNone(tables)
self.assertEqual(len(tables), 1)
await ts.delete_table(table.table_name)
if self.is_live:
sleep(SLEEP_DELAY)
