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)
t = self._create_table(ts)
# Act
tables = list(ts.list_tables())
# Assert
for table_item in tables:
self.assertIsInstance(table_item, TableItem)
self.assertIsNotNone(tables)
self.assertGreaterEqual(len(tables), 1)
self.assertIsNotNone(tables[0])
ts.delete_table(t.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)
t = self._create_table(ts)
# Act
name_filter = "TableName eq '{}'".format(t.table_name)
tables = list(ts.query_tables(filter=name_filter))
for table_item in tables:
self.assertIsInstance(table_item, TableItem)
# Assert
self.assertIsNotNone(tables)
self.assertEqual(len(tables), 1)
ts.delete_table(t.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_unicode_create_table_unicode_name(self, resource_group, location,
cosmos_account,
cosmos_account_key):
# Arrange
url = self.account_url(cosmos_account, "cosmos")
if 'cosmos' in url:
pytest.skip("Cosmos URLs support unicode table names")
ts = TableServiceClient(url, cosmos_account_key)
table_name = u'啊齄丂狛狜'
# Act
with self.assertRaises(HttpResponseError):
ts.create_table(table_name)
if self.is_live:
sleep(SLEEP_DELAY)
def test_create_service_with_custom_account_endpoint_path(self, resource_group, location, storage_account, storage_account_key):
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={};TableEndpoint={};'.format(
storage_account.name, storage_account_key, custom_account_url)
# Act
service = service_type[0].from_connection_string(conn_string, table_name="foo")
# Assert
self.assertEqual(service.account_name, storage_account.name)
self.assertEqual(service.credential.account_name, storage_account.name)
self.assertEqual(service.credential.account_key, storage_account_key)
self.assertEqual(service._primary_hostname, 'local-machine:11002/custom/account/path')
service = TableServiceClient(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 = TableClient(account_url=custom_account_url, table_name="foo")
self.assertEqual(service.account_name, None)
self.assertEqual(service.table_name, "foo")
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 = TableClient.from_table_url("http://local-machine:11002/custom/account/path/foo" + self.sas_token)
self.assertEqual(service.account_name, None)
self.assertEqual(service.table_name, "foo")
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'))
def test_create_service_with_token(self):
url = self.account_url(self.tables_storage_account_name, "table")
suffix = '.table.core.windows.net'
self.token_credential = self.generate_fake_token()
service = TableClient(url,
credential=self.token_credential,
table_name='foo')
# Assert
assert service is not None
assert service.account_name == self.tables_storage_account_name
assert service.url.startswith('https://' +
self.tables_storage_account_name +
suffix)
assert service.credential == self.token_credential
assert not hasattr(service.credential, 'account_key')
assert hasattr(service.credential, 'get_token')
service = TableServiceClient(url,
credential=self.token_credential,
table_name='foo')
# Assert
assert service is not None
assert service.account_name == self.tables_storage_account_name
assert service.url.startswith('https://' +
self.tables_storage_account_name +
suffix)
assert service.credential == self.token_credential
assert not hasattr(service.credential, 'account_key')
assert hasattr(service.credential, 'get_token')
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 = 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)
ts.delete_table(table.table_name)
if self.is_live:
sleep(SLEEP_DELAY)
def tables_in_account(self):
# Instantiate the TableServiceClient from a connection string
from azure.data.tables import TableServiceClient
with TableServiceClient.from_connection_string(
conn_str=self.connection_string) as table_service:
# [START tsc_create_table]
table_service.create_table("mytable1")
table_service.create_table("mytable2")
# [END tsc_create_table]
try:
# [START tsc_list_tables]
# List all the tables in the service
list_tables = table_service.list_tables()
print("Listing tables:")
for table in list_tables:
print("\t{}".format(table.name))
# [END tsc_list_tables]
# [START tsc_query_tables]
table_name = "mytable1"
name_filter = "TableName eq '{}'".format(table_name)
queried_tables = table_service.query_tables(name_filter)
print("Queried_tables")
for table in queried_tables:
print("\t{}".format(table.name))
# [END tsc_query_tables]
finally:
# [START tsc_delete_table]
self.delete_tables()
def test_set_hour_metrics(self, resource_group, location, storage_account, storage_account_key):
# Arrange
url = self.account_url(storage_account, "table")
if 'cosmos' in url:
pytest.skip("Cosmos Tables does not yet support service properties")
tsc = TableServiceClient(url, storage_account_key)
hour_metrics = Metrics(enabled=True, include_apis=True, retention_policy=RetentionPolicy(enabled=True, days=5))
# Act
tsc.set_service_properties(hour_metrics=hour_metrics)
# Assert
if self.is_live:
time.sleep(30)
received_props = tsc.get_service_properties()
self._assert_metrics_equal(received_props['hour_metrics'], hour_metrics)
def test_query_tables(self, resource_group, location, cosmos_account, cosmos_account_key):
# Arrange
ts = TableServiceClient(self.account_url(cosmos_account, "cosmos"), cosmos_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])
ts.delete_table(table.table_name)
if self.is_live:
sleep(SLEEP_DELAY)
def test_set_logging(self, resource_group, location, storage_account, storage_account_key):
# Arrange
url = self.account_url(storage_account, "table")
if 'cosmos' in url:
pytest.skip("Cosmos Tables does not yet support service properties")
tsc = TableServiceClient(url, storage_account_key)
logging = TableAnalyticsLogging(read=True, write=True, delete=True, retention_policy=RetentionPolicy(enabled=True, days=5))
# Act
tsc.set_service_properties(analytics_logging=logging)
# Assert
if self.is_live:
time.sleep(30)
received_props = tsc.get_service_properties()
self._assert_logging_equal(received_props['analytics_logging'], logging)
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 tables_in_account(self):
# Instantiate the TableServiceClient from a connection string
from azure.data.tables import TableServiceClient
table_service = TableServiceClient.from_connection_string(conn_str=self.connection_string)
# [START tsc_create_table]
table_service.create_table("mytable1")
# [END tsc_create_table]
try:
# [START tsc_list_tables]
# List all the tables in the service
list_tables = table_service.query_tables()
for table in list_tables:
print(table)
# List the tables in the service that start with the name "my"
list_my_tables = table_service.query_tables(select="my")
for table in list_my_tables:
print(table)
# [END tsc_list_tables]
finally:
# [START tsc_delete_table]
table_service.delete_table(table_name="mytable1")
def test_get_table_acl(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(self.account_url(storage_account, "table"), storage_account_key)
table = self._create_table(ts)
try:
# Act
acl = table.get_table_access_policy()
# Assert
self.assertIsNotNone(acl)
self.assertEqual(len(acl), 0)
finally:
ts.delete_table(table.table_name)
def test_table_service_properties(self, tables_storage_account_name, tables_primary_storage_account_key):
# Arrange
url = self.account_url(tables_storage_account_name, "table")
tsc = TableServiceClient(url, tables_primary_storage_account_key)
# Act
resp = tsc.set_service_properties(
analytics_logging=TableAnalyticsLogging(),
hour_metrics=Metrics(),
minute_metrics=Metrics(),
cors=list())
# Assert
assert resp is None
if self.is_live:
time.sleep(30)
self._assert_properties_default(tsc.get_service_properties())
def test_create_service_with_custom_account_endpoint_path(self):
token = self.generate_sas_token()
custom_account_url = "http://local-machine:11002/custom/account/path/" + token
for service_type in SERVICES.items():
conn_string = 'DefaultEndpointsProtocol=http;AccountName={};AccountKey={};TableEndpoint={};'.format(
self.tables_storage_account_name, self.tables_primary_storage_account_key, custom_account_url)
# Act
service = service_type[0].from_connection_string(conn_string, table_name="foo")
# Assert
assert service.account_name == self.tables_storage_account_name
assert service.credential.account_name == self.tables_storage_account_name
assert service.credential.account_key == self.tables_primary_storage_account_key
assert service._primary_hostname == 'local-machine:11002/custom/account/path'
service = TableServiceClient(account_url=custom_account_url)
assert service.account_name == "custom"
assert service.credential == None
assert service._primary_hostname == 'local-machine:11002/custom/account/path'
assert service.url.startswith('http://local-machine:11002/custom/account/path')
service = TableClient(account_url=custom_account_url, table_name="foo")
assert service.account_name == "custom"
assert service.table_name == "foo"
assert service.credential == None
assert service._primary_hostname == 'local-machine:11002/custom/account/path'
assert service.url.startswith('http://local-machine:11002/custom/account/path')
service = TableClient.from_table_url("http://local-machine:11002/custom/account/path/foo" + token)
assert service.account_name == "custom"
assert service.table_name == "foo"
assert service.credential == None
assert service._primary_hostname == 'local-machine:11002/custom/account/path'
assert service.url.startswith('http://local-machine:11002/custom/account/path')
def test_table_service_properties(self, tables_cosmos_account_name, tables_primary_cosmos_account_key):
# Arrange
url = self.account_url(tables_cosmos_account_name, "cosmos")
tsc = TableServiceClient(url, tables_primary_cosmos_account_key)
# Act
resp = tsc.set_service_properties(
analytics_logging=TableAnalyticsLogging(),
hour_metrics=Metrics(),
minute_metrics=Metrics(),
cors=list())
# Assert
assert resp is None
self._assert_properties_default(tsc.get_service_properties())
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)
def test_user_agent_default(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 = list(service.list_tables(raw_response_hook=callback))
assert isinstance(tables, list)
count = 0
for table in tables:
count += 1
def test_user_agent_append(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 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
for table in tables:
count += 1
def test_delete_table_with_existing_table(
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 = self._create_table(ts)
# Act
deleted = ts.delete_table(table_name=table.table_name)
# Assert
existing = list(
ts.query_tables("TableName eq '{}'".format(table.table_name)))
assert len(existing) == 0
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"),
credential=tables_primary_cosmos_account_key)
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_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 = self._create_table(ts)
# Act
deleted = ts.delete_table(table_name=table.table_name)
existing = list(
ts.query_tables("TableName eq '{}'".format(table.table_name)))
# Assert
self.assertIsNone(deleted)
self.assertEqual(len(existing), 0)
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()
ts.create_table(table_name)
if table_name not in [t.name for t in ts.list_tables()]:
raise AssertionError("Table could not be found")
ts.delete_table(table_name)
if table_name in [t.name for t in ts.list_tables()]:
raise AssertionError("Table was not deleted")
finally:
ts.delete_table(table_name)
def authentication_by_shared_access_signature(self):
# Instantiate a TableServiceClient using a connection string
# [START auth_from_sas]
from azure.data.tables import TableServiceClient
from azure.core.credentials import AzureNamedKeyCredential, AzureSasCredential
# Create a SAS token to use for authentication of a client
from azure.data.tables import generate_account_sas, ResourceTypes, AccountSasPermissions
print("Account name: {}".format(self.account_name))
credential = AzureNamedKeyCredential(self.account_name,
self.access_key)
sas_token = generate_account_sas(
credential,
resource_types=ResourceTypes(service=True),
permission=AccountSasPermissions(read=True),
expiry=datetime.utcnow() + timedelta(hours=1),
)
with TableServiceClient(endpoint=self.endpoint,
credential=AzureSasCredential(
sas_token)) as token_auth_table_service:
properties = token_auth_table_service.get_service_properties()
print("Shared Access Signature: {}".format(properties))
def test_unicode_create_table_unicode_name(self, resource_group, location,
storage_account,
storage_account_key):
# Arrange
url = self.account_url(storage_account, "table")
if 'cosmos' in url:
pytest.skip("Cosmos URLs do notsupport unicode table names")
ts = TableServiceClient(url, storage_account_key)
table_name = u'啊齄丂狛狜'
# Act
with self.assertRaises(ValueError) as excinfo:
ts.create_table(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_batch_sas_auth(self, tables_cosmos_account_name, tables_primary_cosmos_account_key):
set_bodiless_matcher()
# Arrange
self._set_up(tables_cosmos_account_name, tables_primary_cosmos_account_key, url="cosmos")
try:
token = self.generate_sas(
generate_table_sas,
tables_primary_cosmos_account_key,
self.table_name,
permission=TableSasPermissions(add=True, read=True, update=True, delete=True),
expiry=datetime.utcnow() + timedelta(hours=1),
start=datetime.utcnow() - timedelta(minutes=1),
)
token = AzureSasCredential(token)
# Act
service = TableServiceClient(
self.account_url(tables_cosmos_account_name, "cosmos"),
credential=token,
)
table = service.get_table_client(self.table_name)
entity = TableEntity()
entity['PartitionKey'] = 'batch_inserts'
entity['test'] = EntityProperty(True, EdmType.BOOLEAN)
entity['test2'] = 'value'
entity['test3'] = 3
entity['test4'] = EntityProperty(1234567890, EdmType.INT32)
batch = []
transaction_count = 0
for i in range(10):
entity['RowKey'] = str(i)
batch.append(('create', entity.copy()))
transaction_count += 1
transaction_result = table.submit_transaction(batch)
assert transaction_result
total_entities = 0
for e in table.list_entities():
total_entities += 1
assert total_entities == transaction_count
finally:
self._tear_down()
def test_user_agent_default(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 "azsdk-python-data-tables/{} 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)
# The count doesn't matter, going through the PagedItem calls `callback`
count = 0
for table in tables:
count += 1
def create_table_service_client(self):
# Instantiate a TableServiceClient using a shared access key
# [START create_table_service_client]
from azure.data.tables import TableServiceClient
with TableServiceClient(account_url=self.account_url,
credential=self.access_key) as table_service:
properties = table_service.get_service_properties()
print("Properties: {}".format(properties))