async def test_list_tables_with_marker(self, resource_group, location,
cosmos_account, cosmos_account_key):
# Arrange
ts = TableServiceClient(self.account_url(cosmos_account, "cosmos"),
cosmos_account_key)
prefix = 'listtable'
table_names = []
for i in range(0, 4):
await self._create_table(ts, prefix + str(i), table_names)
# table_names.sort()
# Act
generator1 = ts.list_tables(query_options=QueryOptions(
top=2)).by_page()
tables1 = []
async for el in await generator1:
tables1.append(el)
generator2 = ts.list_tables(query_options=QueryOptions(top=2)).by_page(
continuation_token=generator1.continuation_token)
tables2 = []
async for el in await generator2:
tables2.append(el)
# Assert
assert len(tables1) == 2
assert len(tables2) == 2
assert tables1 != tables2
if self.is_live:
sleep(SLEEP_DELAY)
async def test_list_tables_with_marker(self, resource_group, location,
storage_account,
storage_account_key):
# Arrange
ts = TableServiceClient(self.account_url(storage_account, "table"),
storage_account_key)
prefix = 'listtable'
table_names = []
for i in range(0, 4):
await self._create_table(ts, prefix + str(i), table_names)
# Act
generator1 = ts.list_tables(results_per_page=2).by_page()
await generator1.__anext__()
generator2 = ts.list_tables(results_per_page=2).by_page(
continuation_token=generator1.continuation_token)
await generator2.__anext__()
tables1 = generator1._current_page
tables2 = generator2._current_page
tables1_len = 0
async for _ in tables1:
tables1_len += 1
tables2_len = 0
async for _ in tables2:
tables2_len += 1
# Assert
self.assertEqual(tables1_len, 2)
self.assertEqual(tables2_len, 2)
self.assertNotEqual(tables1, tables2)
async def test_user_agent_custom_async(self, tables_cosmos_account_name,
tables_primary_cosmos_account_key):
custom_app = "TestApp/v1.0"
service = TableServiceClient(
self.account_url(tables_cosmos_account_name, "cosmos"),
credential=tables_primary_cosmos_account_key,
user_agent=custom_app)
def callback(response):
assert 'User-Agent' in response.http_request.headers
assert "TestApp/v1.0 azsdk-python-storage-table/{} Python/{} ({})".format(
VERSION, platform.python_version(), platform.platform()
) in response.http_request.headers['User-Agent']
tables = service.list_tables(raw_response_hook=callback)
assert tables is not None
def callback(response):
assert 'User-Agent' in response.http_request.headers
assert "TestApp/v2.0 TestApp/v1.0 azsdk-python-storage-table/{} Python/{} ({})".format(
VERSION, platform.python_version(), platform.platform()
) in response.http_request.headers['User-Agent']
tables = service.list_tables(raw_response_hook=callback,
user_agent="TestApp/v2.0")
assert tables is not None
async def test_user_agent_custom_async(self, resource_group, location,
storage_account,
storage_account_key):
custom_app = "TestApp/v1.0"
service = TableServiceClient(self.account_url(storage_account,
"table"),
credential=storage_account_key,
user_agent=custom_app)
def callback(response):
self.assertTrue('User-Agent' in response.http_request.headers)
self.assertIn(
"TestApp/v1.0 azsdk-python-data-tables/{} Python/{} ({})".
format(VERSION, platform.python_version(),
platform.platform()),
response.http_request.headers['User-Agent'])
tables = service.list_tables(raw_response_hook=callback)
self.assertIsNotNone(tables)
def callback(response):
self.assertTrue('User-Agent' in response.http_request.headers)
self.assertIn(
"TestApp/v2.0 TestApp/v1.0 azsdk-python-data-tables/{} Python/{} ({})"
.format(VERSION, platform.python_version(),
platform.platform()),
response.http_request.headers['User-Agent'])
tables = service.list_tables(raw_response_hook=callback,
user_agent="TestApp/v2.0")
self.assertIsNotNone(tables)
async def test_user_agent_custom_async(self, tables_storage_account_name, tables_primary_storage_account_key):
custom_app = "TestApp/v1.0"
service = TableServiceClient(
self.account_url(tables_storage_account_name, "table"), credential=tables_primary_storage_account_key, user_agent=custom_app)
def callback(response):
assert 'User-Agent' in response.http_request.headers
assert "TestApp/v1.0 azsdk-python-data-tables/{} Python/{} ({})".format(
VERSION,
platform.python_version(),
platform.platform()) in response.http_request.headers['User-Agent']
tables = service.list_tables(raw_response_hook=callback)
assert tables is not None
# The count doesn't matter, going through the PagedItem calls `callback`
count = 0
async for table in tables:
count += 1
def callback(response):
assert 'User-Agent' in response.http_request.headers
assert "TestApp/v2.0 TestApp/v1.0 azsdk-python-data-tables/{} Python/{} ({})".format(
VERSION,
platform.python_version(),
platform.platform()) in response.http_request.headers['User-Agent']
tables = service.list_tables(raw_response_hook=callback, user_agent="TestApp/v2.0")
assert tables is not None
# The count doesn't matter, going through the PagedItem calls `callback`
count = 0
async for table in tables:
count += 1
async def test_list_tables_with_marker(self, resource_group, location,
cosmos_account, cosmos_account_key):
# Arrange
ts = TableServiceClient(self.account_url(cosmos_account, "cosmos"),
cosmos_account_key)
prefix = 'listtable'
table_names = []
for i in range(0, 4):
await self._create_table(ts, prefix + str(i), table_names)
# Act
generator1 = ts.list_tables(results_per_page=2).by_page()
await generator1.__anext__()
generator2 = ts.list_tables(results_per_page=2).by_page(
continuation_token=generator1.continuation_token)
await generator2.__anext__()
tables1 = generator1._current_page
tables2 = generator2._current_page
tables1_len = 0
async for _ in tables1:
tables1_len += 1
tables2_len = 0
async for _ in tables2:
tables2_len += 1
# Assert
assert tables1_len == 2
assert tables2_len == 2
assert tables1 != tables2
if self.is_live:
sleep(SLEEP_DELAY)
async def test_user_agent_custom_async(self, resource_group, location,
cosmos_account, cosmos_account_key):
custom_app = "TestApp/v1.0"
service = TableServiceClient(self.account_url(cosmos_account,
"cosmos"),
credential=cosmos_account_key,
user_agent=custom_app)
def callback(response):
assert 'User-Agent' in response.http_request.headers
assert "TestApp/v1.0 azsdk-python-storage-table/{} Python/{} ({})".format(
VERSION, platform.python_version(), platform.platform()
) in response.http_request.headers['User-Agent']
tables = list(service.list_tables(raw_response_hook=callback))
assert isinstance(tables, list)
def callback(response):
assert 'User-Agent' in response.http_request.headers
assert "TestApp/v2.0 TestApp/v1.0 azsdk-python-storage-table/{} Python/{} ({})".format(
VERSION, platform.python_version(), platform.platform()
) in response.http_request.headers['User-Agent']
tables = list(
service.list_tables(raw_response_hook=callback,
user_agent="TestApp/v2.0"))
assert isinstance(tables, list)
async def test_list_tables_with_num_results(self, tables_storage_account_name, tables_primary_storage_account_key):
# Arrange
prefix = 'listtable'
account_url = self.account_url(tables_storage_account_name, "table")
ts = TableServiceClient(credential=tables_primary_storage_account_key, endpoint=account_url)
# Delete any existing tables
async for table in ts.list_tables():
await ts.delete_table(table.name)
table_list = []
for i in range(0, 4):
await self._create_table(ts, prefix + str(i), table_list)
# Act
big_page = []
async for t in ts.list_tables():
big_page.append(t)
small_page = []
async for s in ts.list_tables(results_per_page=3).by_page():
small_page.append(s)
assert len(small_page) == 2
assert len(big_page) >= 4
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_list_tables_with_num_results(
self, tables_cosmos_account_name,
tables_primary_cosmos_account_key):
# Arrange
await self._delete_all_tables(tables_cosmos_account_name,
tables_primary_cosmos_account_key)
prefix = 'listtable'
ts = TableServiceClient(
self.account_url(tables_cosmos_account_name, "cosmos"),
tables_primary_cosmos_account_key)
table_list = []
for i in range(0, 4):
await self._create_table(ts, prefix + str(i), table_list)
# Act
all_tables = 0
async for t in ts.list_tables():
all_tables += 1
small_page = 0
async for page in ts.list_tables(results_per_page=3).by_page():
page_size = 0
async for table in page:
page_size += 1
assert page_size <= 3
small_page += 1
assert small_page == 2
assert all_tables == 4
async def test_list_tables_with_num_results(self, resource_group, location,
cosmos_account,
cosmos_account_key):
# Arrange
prefix = 'listtable'
ts = TableServiceClient(self.account_url(cosmos_account, "cosmos"),
cosmos_account_key)
table_list = []
for i in range(0, 4):
await self._create_table(ts, prefix + str(i), table_list)
# Act
big_page = []
async for t in ts.list_tables():
big_page.append(t)
small_page = []
async for s in ts.list_tables(results_per_page=3).by_page():
small_page.append(s)
self.assertEqual(len(small_page), 2)
self.assertGreaterEqual(len(big_page), 4)
if self.is_live:
sleep(SLEEP_DELAY)
async def test_list_tables_with_marker(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)
prefix = 'listtable'
table_names = []
for i in range(0, 4):
await self._create_table(ts, prefix + str(i), table_names)
# Act
generator1 = ts.list_tables(results_per_page=2).by_page()
await generator1.__anext__()
generator2 = ts.list_tables(results_per_page=2).by_page(
continuation_token=generator1.continuation_token)
await generator2.__anext__()
tables1 = generator1._current_page
tables2 = generator2._current_page
tables1_len = 0
async for _ in tables1:
tables1_len += 1
tables2_len = 0
async for _ in tables2:
tables2_len += 1
# Assert
assert tables1_len == 2
assert tables2_len == 2
assert tables1 != tables2
async def test_list_tables_with_marker(self, resource_group, location,
storage_account,
storage_account_key):
# Arrange
ts = TableServiceClient(self.account_url(storage_account, "table"),
storage_account_key)
prefix = 'listtable'
table_names = []
for i in range(0, 4):
await self._create_table(ts, prefix + str(i), table_names)
# table_names.sort()
# Act
generator1 = ts.list_tables(query_options=QueryOptions(
top=2)).by_page()
tables1 = []
async for el in await generator1: #.__anext__():
tables1.append(el)
generator2 = ts.list_tables(query_options=QueryOptions(top=2)).by_page(
continuation_token=generator1.continuation_token)
tables2 = []
async for el in await generator2: # .__anext__():
tables2.append(el)
# Assert
self.assertEqual(len(tables1), 2)
self.assertEqual(len(tables2), 2)
self.assertNotEqual(tables1, tables2)
async def test_list_tables_with_num_results(
self, tables_cosmos_account_name,
tables_primary_cosmos_account_key):
# Arrange
prefix = 'listtable'
ts = TableServiceClient(
self.account_url(tables_cosmos_account_name, "cosmos"),
tables_primary_cosmos_account_key)
table_list = []
for i in range(0, 4):
await self._create_table(ts, prefix + str(i), table_list)
# Act
big_page = []
async for t in ts.list_tables():
big_page.append(t)
small_page = []
async for s in ts.list_tables(results_per_page=3).by_page():
small_page.append(s)
assert len(small_page) == 2
assert len(big_page) >= 4
if self.is_live:
sleep(SLEEP_DELAY)
async def _delete_all_tables(self, account_name, key):
client = TableServiceClient(self.account_url(account_name, "cosmos"), key)
async for table in client.list_tables():
await client.delete_table(table.name)
if self.is_live:
self.sleep(10)
async 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
await table.create_table()
try:
resp = ts.list_tables()
except:
e = sys.exc_info()[0]
# Assert
self.assertIsNone(e)
finally:
await ts.delete_table(table.table_name)
locale.setlocale(locale.LC_ALL, init_locale[0] or 'en_US')
async 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
await ts.create_table(table)
resp = ts.list_tables()
e = sys.exc_info()[0]
# Assert
assert e is None
await ts.delete_table(table)
locale.setlocale(locale.LC_ALL, init_locale[0] or 'en_US')
if self.is_live:
sleep(SLEEP_DELAY)
async def test_aad_create_table(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_name = self._get_table_reference()
await ts.create_table(table_name)
if table_name not in [t.name async for t in ts.list_tables()]:
raise AssertionError("Table could not be found")
await ts.delete_table(table_name)
if table_name in [t.name async for t in ts.list_tables()]:
raise AssertionError("Table was not deleted")
finally:
await ts.delete_table(table_name)
async def test_user_agent_default_async(self, tables_storage_account_name, tables_primary_storage_account_key):
service = TableServiceClient(self.account_url(tables_storage_account_name, "table"), credential=tables_primary_storage_account_key)
def callback(response):
assert 'User-Agent' in response.http_request.headers
assert response.http_request.headers['User-Agent'] in "azsdk-python-data-tables/{} Python/{} ({})".format(
VERSION,
platform.python_version(),
platform.platform())
tables = service.list_tables(raw_response_hook=callback)
assert tables is not None
async def test_user_agent_default_async(self, resource_group, location, cosmos_account, cosmos_account_key):
service = TableServiceClient(self.account_url(cosmos_account, "cosmos"), credential=cosmos_account_key)
def callback(response):
assert 'User-Agent' in response.http_request.headers
assert response.http_request.headers['User-Agent'] == "azsdk-python-storage-table/{} Python/{} ({})".format(
VERSION,
platform.python_version(),
platform.platform())
tables = service.list_tables(raw_response_hook=callback)
assert tables is not None
async def test_user_agent_append(self, tables_storage_account_name, tables_primary_storage_account_key):
# TODO: fix this one
service = TableServiceClient(self.account_url(tables_storage_account_name, "table"), credential=tables_primary_storage_account_key)
def callback(response):
assert 'User-Agent' in response.http_request.headers
assert response.http_request.headers['User-Agent'] == "azsdk-python-data-tables/{} Python/{} ({}) customer_user_agent".format(
VERSION,
platform.python_version(),
platform.platform())
custom_headers = {'User-Agent': 'customer_user_agent'}
tables = service.list_tables(raw_response_hook=callback, headers=custom_headers)
async def test_user_agent_append(self, resource_group, location, cosmos_account, cosmos_account_key):
# TODO: fix this one
service = TableServiceClient(self.account_url(cosmos_account, "cosmos"), credential=cosmos_account_key)
def callback(response):
assert 'User-Agent' in response.http_request.headers
assert response.http_request.headers['User-Agent'] == "azsdk-python-storage-tables/{} Python/{} ({}) customer_user_agent".format(
VERSION,
platform.python_version(),
platform.platform())
custom_headers = {'User-Agent': 'customer_user_agent'}
tables = service.list_tables(raw_response_hook=callback, headers=custom_headers)
async def test_query_tables_with_num_results(self, resource_group,
location, storage_account,
storage_account_key):
# Arrange
prefix = 'listtable'
ts = TableServiceClient(self.account_url(storage_account, "table"),
storage_account_key)
table_list = []
for i in range(0, 4):
await self._create_table(ts, prefix + str(i), table_list)
# Act
small_page = []
big_page = []
for s in next(ts.list_tables(results_per_page=3).by_page()):
small_page.append(s)
for t in next(ts.list_tables().by_page()):
big_page.append(t)
# Assert
self.assertEqual(len(small_page), 3)
self.assertGreaterEqual(len(big_page), 4)
async def test_list_tables(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
tables = []
async for t in ts.list_tables():
tables.append(t)
# Assert
self.assertIsNotNone(tables)
self.assertGreaterEqual(len(tables), 1)
self.assertIsNotNone(tables[0])
async def test_account_sas(self, resource_group, location, cosmos_account,
cosmos_account_key):
# SAS URL is calculated from storage key, so this test runs live only
# Arrange
url = self.account_url(cosmos_account, "cosmos")
if 'cosmos' in url:
pytest.skip("Cosmos Tables does not yet support sas")
tsc = TableServiceClient(url, cosmos_account_key)
table = await self._create_table(tsc)
try:
entity = {
'PartitionKey': 'test',
'RowKey': 'test1',
'text': 'hello',
}
await table.upsert_insert_merge_entity(
table_entity_properties=entity)
entity['RowKey'] = 'test2'
await table.upsert_insert_merge_entity(
table_entity_properties=entity)
token = generate_account_sas(
cosmos_account.name,
cosmos_account_key,
resource_types=ResourceTypes(container=True),
permission=AccountSasPermissions(list=True),
expiry=datetime.utcnow() + timedelta(hours=1),
start=datetime.utcnow() - timedelta(minutes=1),
)
# Act
service = TableServiceClient(
self.account_url(cosmos_account, "cosmos"),
credential=token,
)
entities = []
async for e in service.list_tables():
entities.append(e)
# Assert
self.assertEqual(len(entities), 1)
# self.assertEqual(entities[0].text, 'hello')
# self.assertEqual(entities[1].text, 'hello')
finally:
await self._delete_table(table=table, ts=tsc)
if self.is_live:
sleep(SLEEP_DELAY)
async def test_user_agent_append(self, tables_storage_account_name, tables_primary_storage_account_key):
service = TableServiceClient(self.account_url(tables_storage_account_name, "table"), credential=tables_primary_storage_account_key)
def callback(response):
assert 'User-Agent' in response.http_request.headers
assert response.http_request.headers['User-Agent'] == 'customer_user_agent'
custom_headers = {'User-Agent': 'customer_user_agent'}
tables = service.list_tables(raw_response_hook=callback, headers=custom_headers)
# The count doesn't matter, going through the PagedItem calls `callback`
count = 0
async for table in tables:
count += 1
async def test_user_agent_default_async(self, resource_group, location,
storage_account,
storage_account_key):
service = TableServiceClient(self.account_url(storage_account,
"table"),
credential=storage_account_key)
def callback(response):
self.assertTrue('User-Agent' in response.http_request.headers)
self.assertEqual(
response.http_request.headers['User-Agent'],
"azsdk-python-storage-table/{} Python/{} ({})".format(
VERSION, platform.python_version(), platform.platform()))
tables = list(service.list_tables(raw_response_hook=callback))
self.assertIsInstance(tables, list)
async def test_user_agent_default_async(self, tables_cosmos_account_name, tables_primary_cosmos_account_key):
service = TableServiceClient(self.account_url(tables_cosmos_account_name, "cosmos"), credential=tables_primary_cosmos_account_key)
def callback(response):
assert 'User-Agent' in response.http_request.headers
assert "azsdk-python-data-tables/{} Python/{} ({})".format(
VERSION,
platform.python_version(),
platform.platform()) in response.http_request.headers['User-Agent']
tables = service.list_tables(raw_response_hook=callback)
assert tables is not None
# The count doesn't matter, going through the PagedItem calls `callback`
count = 0
async for table in tables:
count += 1
async def test_list_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 = await self._create_table(ts)
# Act
tables = []
async for t in ts.list_tables():
tables.append(t)
# Assert
assert tables is not None
assert len(tables) >= 1
assert tables[0] is not None
if self.is_live:
sleep(SLEEP_DELAY)
async def test_account_sas(self, tables_cosmos_account_name,
tables_primary_cosmos_account_key):
# SAS URL is calculated from storage key, so this test runs live only
# Arrange
url = self.account_url(tables_cosmos_account_name, "cosmos")
tsc = TableServiceClient(url, tables_primary_cosmos_account_key)
table = await self._create_table(tsc)
try:
entity = {
'PartitionKey': 'test',
'RowKey': 'test1',
'text': 'hello',
}
await table.upsert_insert_merge_entity(
table_entity_properties=entity)
entity['RowKey'] = 'test2'
await table.upsert_insert_merge_entity(
table_entity_properties=entity)
token = generate_account_sas(
tables_cosmos_account_name,
tables_primary_cosmos_account_key,
resource_types=ResourceTypes(container=True),
permission=AccountSasPermissions(list=True),
expiry=datetime.utcnow() + timedelta(hours=1),
start=datetime.utcnow() - timedelta(minutes=1),
)
# Act
service = TableServiceClient(
self.account_url(tables_cosmos_account_name, "cosmos"),
credential=token,
)
entities = []
async for e in service.list_tables():
entities.append(e)
# Assert
assert len(entities) == 1
finally:
await self._delete_table(table=table, ts=tsc)
if self.is_live:
sleep(SLEEP_DELAY)
