def testListTablesWithStartIndex(self):
last_returned_index = [3, 4]
# set a start index larger than the number of tables
self.list_tables_request.set_start_index(5)
for handle in range(self.num_handles):
result = self.handles[handle].list_tables(self.list_tables_request)
# TODO: add and use startIndex,numTables.
if not not_cloudsim():
self.assertEqual(result.get_tables(), [])
self.assertEqual(result.get_last_returned_index(),
last_returned_index[handle])
# set start_index = 1
part_table_names = [[
make_table_name('Users1'),
make_table_name('Users2')
],
[
make_table_name('Users1'),
make_table_name('Users2'),
make_table_name('Users3')
]]
self.list_tables_request.set_start_index(1)
for handle in range(self.num_handles):
result = self.handles[handle].list_tables(self.list_tables_request)
# TODO: add and use startIndex,numTables.
if not not_cloudsim():
self.assertEqual(result.get_tables(), part_table_names[handle])
self.assertEqual(result.get_last_returned_index(),
last_returned_index[handle])
def setUpClass(cls):
cls.handle = None
cls.set_up_class()
create_statement = ('CREATE TABLE ' + table_name +
'(fld_id INTEGER, fld_long LONG, \
fld_float FLOAT, fld_double DOUBLE, fld_bool BOOLEAN, fld_str STRING, \
fld_bin BINARY, fld_time TIMESTAMP(7), fld_num NUMBER, fld_json JSON, \
fld_arr ARRAY(STRING), fld_map MAP(STRING), \
fld_rec RECORD(fld_id LONG, fld_bool BOOLEAN, fld_str STRING), \
PRIMARY KEY(fld_id)) USING TTL 1 HOURS')
limits = TableLimits(5000, 5000, 50)
create_request = TableRequest().set_statement(
create_statement).set_table_limits(limits)
cls.table_request(create_request)
# put and get some data, read_units = 100, write_units = 199
row = get_row()
key = {'fld_id': 1}
put_request = PutRequest().set_value(row).set_table_name(table_name)
get_request = GetRequest().set_key(key).set_table_name(table_name)
count = 0
while count < 100:
cls.handle.put(put_request)
cls.handle.get(get_request)
count += 1
# sleep to allow records to accumulate over time, but not if
# using Cloudsim.
if not_cloudsim() and not is_onprem():
sleep(2)
# need to sleep to allow usage records to accumulate but not if
# using CloudSim, which doesn't generate usage records.
if not_cloudsim() and not is_onprem():
sleep(40)
def testTableUsageWithStartEndTimeAndLimit(self):
# start time, end time and limit
current = int(round(time() * 1000))
start_time = current - 180000
self.table_usage_request.set_table_name(table_name).set_start_time(
start_time).set_end_time(current).set_limit(2)
if is_onprem():
self.assertRaises(OperationNotSupportedException,
self.handle.get_table_usage,
self.table_usage_request)
return
result = self.handle.get_table_usage(self.table_usage_request)
self._check_table_usage_result(result, 2 if not_cloudsim() else 1,
start_time, current)
# start time, end time in ISO 8601 formatted string and limit
current = datetime.now()
start_str = (current + timedelta(seconds=-180)).isoformat()
end_str = (current + timedelta(seconds=-60)).isoformat()
start_time = int(
mktime(
datetime.strptime(start_str,
'%Y-%m-%dT%H:%M:%S.%f').timetuple()) * 1000)
end_time = int(
mktime(
datetime.strptime(end_str, '%Y-%m-%dT%H:%M:%S.%f').timetuple())
* 1000)
self.table_usage_request.set_start_time(start_str).set_end_time(
end_str)
result = self.handle.get_table_usage(self.table_usage_request)
self._check_table_usage_result(result, 2 if not_cloudsim() else 1,
start_time, end_time)
def testTableRequestModifyTableLimits(self):
# create table before modifying the table limits
request = TableRequest().set_statement(
self.create_tb_statement).set_table_limits(self.table_limits)
result = self.handle.table_request(request)
result.wait_for_state(self.handle, table_name, State.ACTIVE,
wait_timeout, 1000)
# modify the table limits
table_limits = TableLimits(10000, 10000, 100)
self.table_request.set_table_name(table_name).set_table_limits(
table_limits)
result = self.handle.table_request(self.table_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(result.get_state(), State.UPDATING)
if not_cloudsim():
self.assertIsNotNone(result.get_schema())
wait_result = result.wait_for_state(self.handle, table_name,
State.ACTIVE, wait_timeout, 1000)
self.assertEqual(wait_result.get_table_name(), table_name)
self.assertEqual(wait_result.get_state(), State.ACTIVE)
self.assertEqual(wait_result.get_table_limits().get_read_units(),
table_limits.get_read_units())
self.assertEqual(wait_result.get_table_limits().get_write_units(),
table_limits.get_write_units())
self.assertEqual(wait_result.get_table_limits().get_storage_gb(),
table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(wait_result.get_schema())
self.assertIsNone(wait_result.get_operation_id())
# drop table after modifying the table limits
request.set_statement(self.drop_tb_statement)
result = self.handle.table_request(request)
result.wait_for_state(self.handle, table_name, State.DROPPED,
wait_timeout, 1000)
def testTableRequestCreateDropTable(self):
# create table failed without TableLimits set
self.table_request.set_statement(self.create_tb_statement)
self.assertRaises(IllegalArgumentException, self.handle.table_request,
self.table_request)
# create table succeed with TableLimits set
self.table_request.set_table_limits(self.table_limits)
result = self.handle.table_request(self.table_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(result.get_state(), State.CREATING)
self.assertEqual(result.get_table_limits().get_read_units(),
self.table_limits.get_read_units())
self.assertEqual(result.get_table_limits().get_write_units(),
self.table_limits.get_write_units())
self.assertEqual(result.get_table_limits().get_storage_gb(),
self.table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNone(result.get_schema())
wait_result = result.wait_for_state(self.handle, table_name,
State.ACTIVE, wait_timeout, 1000)
self.assertEqual(wait_result.get_table_name(), table_name)
self.assertEqual(wait_result.get_state(), State.ACTIVE)
self.assertEqual(wait_result.get_table_limits().get_read_units(),
self.table_limits.get_read_units())
self.assertEqual(wait_result.get_table_limits().get_write_units(),
self.table_limits.get_write_units())
self.assertEqual(wait_result.get_table_limits().get_storage_gb(),
self.table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(wait_result.get_schema())
self.assertIsNone(wait_result.get_operation_id())
# drop table by resetting the statement
self.table_request.set_statement(self.drop_tb_statement)
result = self.handle.table_request(self.table_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(result.get_state(), State.DROPPING)
self.assertEqual(result.get_table_limits().get_read_units(),
self.table_limits.get_read_units())
self.assertEqual(result.get_table_limits().get_write_units(),
self.table_limits.get_write_units())
self.assertEqual(result.get_table_limits().get_storage_gb(),
self.table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(wait_result.get_schema())
wait_result = result.wait_for_state(self.handle, table_name,
State.DROPPED, wait_timeout, 1000)
self.assertEqual(wait_result.get_table_name(), table_name)
self.assertEqual(wait_result.get_state(), State.DROPPED)
self.assertEqual(wait_result.get_table_limits().get_read_units(),
self.table_limits.get_read_units())
self.assertEqual(wait_result.get_table_limits().get_write_units(),
self.table_limits.get_write_units())
self.assertEqual(wait_result.get_table_limits().get_storage_gb(),
self.table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNone(wait_result.get_schema())
self.assertIsNone(wait_result.get_operation_id())
def setUpClass(cls):
TestBase.set_up_class()
create_statement = ('CREATE TABLE ' + table_name +
'(fld_id INTEGER, fld_long LONG, \
fld_float FLOAT, fld_double DOUBLE, fld_bool BOOLEAN, fld_str STRING, \
fld_bin BINARY, fld_time TIMESTAMP(7), fld_num NUMBER, fld_json JSON, \
fld_arr ARRAY(STRING), fld_map MAP(STRING), \
fld_rec RECORD(fld_id LONG, fld_bool BOOLEAN, fld_str STRING), \
PRIMARY KEY(fld_id)) USING TTL 1 HOURS')
limits = TableLimits(5000, 5000, 50)
create_request = TableRequest().set_statement(
create_statement).set_table_limits(limits)
cls._result = TestBase.table_request(create_request, State.ACTIVE)
# put and get some data, read_units = 100, write_units = 199
row = {
'fld_id': 1,
'fld_long': 2147483648,
'fld_float': 3.1414999961853027,
'fld_double': 3.1415,
'fld_bool': True,
'fld_str': '{"name": u1, "phone": null}',
'fld_bin': bytearray(pack('>i', 4)),
'fld_time': datetime.now(),
'fld_num': Decimal(5),
'fld_json': {
'a': '1',
'b': None,
'c': '3'
},
'fld_arr': ['a', 'b', 'c'],
'fld_map': {
'a': '1',
'b': '2',
'c': '3'
},
'fld_rec': {
'fld_id': 1,
'fld_bool': False,
'fld_str': None
}
}
key = {'fld_id': 1}
put_request = PutRequest().set_value(row).set_table_name(table_name)
get_request = GetRequest().set_key(key).set_table_name(table_name)
count = 0
while count < 100:
cls._handle.put(put_request)
cls._handle.get(get_request)
count += 1
# sleep to allow records to accumulate over time, but not if
# using Cloudsim.
if not_cloudsim():
sleep(2)
# need to sleep to allow usage records to accumulate but not if
# using CloudSim, which doesn't generate usage records.
if not_cloudsim():
sleep(40)
def testTableUsageWithStartTimeAndLimit(self):
# set the start time and limit
start_time = int(round(time() * 1000)) - 240000
limit = 2
self.table_usage_request.set_table_name(table_name).set_start_time(
start_time).set_limit(limit)
result = self.handle.get_table_usage(self.table_usage_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(len(result.get_usage_records()),
limit if not_cloudsim() else 1)
records = result.get_usage_records()
for count in range(len(records)):
start_time_res = records[count].get_start_time()
self.assertEqual(
records[count].get_start_time_string(),
datetime.fromtimestamp(float(start_time_res) /
1000).isoformat())
self.assertGreater(records[count].get_read_units(), 0)
self.assertGreater(records[count].get_write_units(), 0)
if not_cloudsim():
self.assertGreater(start_time_res, start_time + count * 60000)
self.assertLess(start_time_res,
start_time + (count + 1) * 60000)
self.assertEqual(records[count].get_seconds_in_period(), 60)
self.assertLessEqual(records[count].get_storage_gb(), 0)
self.assertEqual(records[count].get_read_throttle_count(), 0)
self.assertEqual(records[count].get_write_throttle_count(), 0)
self.assertEqual(records[count].get_storage_throttle_count(), 0)
# set the start time in ISO 8601 formatted string and limit
start_str = (datetime.now() + timedelta(seconds=-240)).isoformat()
start_time = int(
mktime(
datetime.strptime(start_str,
'%Y-%m-%dT%H:%M:%S.%f').timetuple()) * 1000)
self.table_usage_request.set_start_time(start_str)
result = self.handle.get_table_usage(self.table_usage_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(len(result.get_usage_records()),
limit if not_cloudsim() else 1)
records = result.get_usage_records()
for count in range(len(records)):
start_time_res = records[count].get_start_time()
self.assertEqual(
records[count].get_start_time_string(),
datetime.fromtimestamp(float(start_time_res) /
1000).isoformat())
self.assertGreater(records[count].get_read_units(), 0)
self.assertGreater(records[count].get_write_units(), 0)
if not_cloudsim():
self.assertGreater(start_time_res, start_time + count * 60000)
self.assertLess(start_time_res,
start_time + (count + 1) * 60000)
self.assertEqual(records[count].get_seconds_in_period(), 60)
self.assertLessEqual(records[count].get_storage_gb(), 0)
self.assertEqual(records[count].get_read_throttle_count(), 0)
self.assertEqual(records[count].get_write_throttle_count(), 0)
self.assertEqual(records[count].get_storage_throttle_count(), 0)
def testTableUsageWithStartTime(self):
# set the start time
start_time = int(round(time() * 1000)) - 120000
self.table_usage_request.set_table_name(table_name).set_start_time(
start_time)
result = self.handle.get_table_usage(self.table_usage_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(len(result.get_usage_records()), 1)
for usage_record in result.get_usage_records():
start_time_res = usage_record.get_start_time()
self.assertEqual(
usage_record.get_start_time_string(),
datetime.fromtimestamp(float(start_time_res) /
1000).isoformat())
self.assertGreater(usage_record.get_read_units(), 0)
self.assertGreater(usage_record.get_write_units(), 0)
if not_cloudsim():
self.assertGreater(start_time_res, start_time)
self.assertLess(start_time_res, start_time + 60000)
self.assertEqual(usage_record.get_seconds_in_period(), 60)
self.assertLessEqual(usage_record.get_storage_gb(), 0)
self.assertEqual(usage_record.get_read_throttle_count(), 0)
self.assertEqual(usage_record.get_write_throttle_count(), 0)
self.assertEqual(usage_record.get_storage_throttle_count(), 0)
# set the start time in ISO 8601 formatted string
start_str = (datetime.now() + timedelta(seconds=-120)).isoformat()
start_time = int(
mktime(
datetime.strptime(start_str,
'%Y-%m-%dT%H:%M:%S.%f').timetuple()) * 1000)
self.table_usage_request.set_start_time(start_str)
result = self.handle.get_table_usage(self.table_usage_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(len(result.get_usage_records()), 1)
for usage_record in result.get_usage_records():
start_time_res = usage_record.get_start_time()
self.assertEqual(
usage_record.get_start_time_string(),
datetime.fromtimestamp(float(start_time_res) /
1000).isoformat())
self.assertGreater(usage_record.get_read_units(), 0)
self.assertGreater(usage_record.get_write_units(), 0)
if not_cloudsim():
self.assertGreater(start_time_res, start_time)
self.assertLess(start_time_res, start_time + 60000)
self.assertEqual(usage_record.get_seconds_in_period(), 60)
self.assertLessEqual(usage_record.get_storage_gb(), 0)
self.assertEqual(usage_record.get_read_throttle_count(), 0)
self.assertEqual(usage_record.get_write_throttle_count(), 0)
self.assertEqual(usage_record.get_storage_throttle_count(), 0)
def check_table_result(self,
result,
state,
table_limits=None,
has_schema=True,
has_operation_id=True,
check_limit=True):
assert isinstance(self, TestCase)
# check table name
self.assertEqual(result.get_table_name(), table_name)
# check state
self.assertEqual(result.get_state(), state)
# check table limits
if check_limit:
if is_onprem() or table_limits is None:
self.assertIsNone(result.get_table_limits())
else:
self.assertEqual(result.get_table_limits().get_read_units(),
table_limits.get_read_units())
self.assertEqual(result.get_table_limits().get_write_units(),
table_limits.get_write_units())
self.assertEqual(result.get_table_limits().get_storage_gb(),
table_limits.get_storage_gb())
# check table schema
# TODO: For on-prem proxy, TableResult.get_schema() always return None,
# This is a known bug, when it is fixed, the test should be change.
if not_cloudsim() and not is_onprem():
(self.assertIsNotNone(result.get_schema())
if has_schema else self.assertIsNone(result.get_schema()))
# check operation id
operation_id = result.get_operation_id()
(self.assertIsNotNone(operation_id)
if has_operation_id else self.assertIsNone(operation_id))
def testTableUsageWithEndTime(self):
# set a start time to avoid unexpected table usage information, and set
# the end time
current = int(round(time() * 1000))
start_time = current - 120000
end_time = current - 180000
self.table_usage_request.set_table_name(table_name).set_start_time(
start_time).set_end_time(end_time)
if is_onprem():
self.assertRaises(OperationNotSupportedException,
self.handle.get_table_usage,
self.table_usage_request)
return
result = self.handle.get_table_usage(self.table_usage_request)
self._check_table_usage_result(result, 0 if not_cloudsim() else 1)
# set current time as end time
self.table_usage_request.set_end_time(current)
result = self.handle.get_table_usage(self.table_usage_request)
self._check_table_usage_result(result, 1, start_time, current)
# set current time in ISO 8601 formatted string as end time
end_str = datetime.now().isoformat()
end_time = int(
mktime(
datetime.strptime(end_str, '%Y-%m-%dT%H:%M:%S.%f').timetuple())
* 1000)
self.table_usage_request.set_end_time(end_str)
result = self.handle.get_table_usage(self.table_usage_request)
self._check_table_usage_result(result, 1, start_time, end_time)
def testTableUsageWithLimit(self):
# set the limit
self.table_usage_request.set_table_name(table_name).set_limit(3)
result = self.handle.get_table_usage(self.table_usage_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(len(result.get_usage_records()), 1)
current = int(round(time() * 1000))
for usage_record in result.get_usage_records():
start_time_res = usage_record.get_start_time()
self.assertIsNotNone(start_time_res)
self.assertEqual(
usage_record.get_start_time_string(),
datetime.fromtimestamp(float(start_time_res) /
1000).isoformat())
self.assertGreater(usage_record.get_read_units(), 0)
self.assertGreater(usage_record.get_write_units(), 0)
if not_cloudsim():
# the record is generated in 1 min
# self.assertGreater(start_time_res, current - 60000)
self.assertGreater(start_time_res, current - 60000 * 2)
self.assertLess(start_time_res, current)
self.assertLessEqual(usage_record.get_seconds_in_period(), 60)
self.assertLessEqual(usage_record.get_storage_gb(), 0)
self.assertEqual(usage_record.get_read_throttle_count(), 0)
self.assertEqual(usage_record.get_write_throttle_count(), 0)
self.assertEqual(usage_record.get_storage_throttle_count(), 0)
def testTableUsageSetIllegalTableName(self):
self.assertRaises(IllegalArgumentException,
self.table_usage_request.set_table_name,
{'name': table_name})
if not is_onprem and not_cloudsim():
self.table_usage_request.set_table_name('IllegalTable')
self.assertRaises(TableNotFoundException,
self.handle.get_table_usage,
self.table_usage_request)
def testListTablesNormal(self):
last_returned_index = [3, 4]
for handle in range(self.num_handles):
result = self.handles[handle].list_tables(self.list_tables_request)
# TODO: add and use startIndex,numTables.
if not not_cloudsim():
self.assertEqual(result.get_tables(), table_names[handle])
self.assertEqual(result.get_last_returned_index(),
last_returned_index[handle])
def testTableRequestAlterTableTTL(self):
# create table before altering table
request = TableRequest().set_statement(
self.create_tb_statement).set_table_limits(self.table_limits)
result = self.handle.table_request(request)
result.wait_for_state(self.handle, table_name, State.ACTIVE,
wait_timeout, 1000)
# alter table ttl
self.table_request.set_statement(self.alter_ttl_statement)
result = self.handle.table_request(self.table_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(result.get_state(), State.UPDATING)
self.assertEqual(result.get_table_limits().get_read_units(),
self.table_limits.get_read_units())
self.assertEqual(result.get_table_limits().get_write_units(),
self.table_limits.get_write_units())
self.assertEqual(result.get_table_limits().get_storage_gb(),
self.table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(result.get_schema())
wait_result = result.wait_for_state(self.handle, table_name,
State.ACTIVE, wait_timeout, 1000)
self.assertEqual(wait_result.get_table_name(), table_name)
self.assertEqual(wait_result.get_state(), State.ACTIVE)
self.assertEqual(wait_result.get_table_limits().get_read_units(),
self.table_limits.get_read_units())
self.assertEqual(wait_result.get_table_limits().get_write_units(),
self.table_limits.get_write_units())
self.assertEqual(wait_result.get_table_limits().get_storage_gb(),
self.table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(wait_result.get_schema())
self.assertIsNone(wait_result.get_operation_id())
# drop table after altering table
request.set_statement(self.drop_tb_statement)
result = self.handle.table_request(request)
result.wait_for_state(self.handle, table_name, State.DROPPED,
wait_timeout, 1000)
def testGetTableNormal(self):
self.get_table_request.set_table_name(table_name)
result = self.handle.get_table(self.get_table_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(result.get_state(), State.ACTIVE)
self.assertEqual(result.get_table_limits().get_read_units(),
table_limits.get_read_units())
self.assertEqual(result.get_table_limits().get_write_units(),
table_limits.get_write_units())
self.assertEqual(result.get_table_limits().get_storage_gb(),
table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(result.get_schema())
self.assertIsNone(result.get_operation_id())
def testTableUsageWithStartTimeAndLimit(self):
# set the start time and limit
start_time = int(round(time() * 1000)) - 240000
limit = 2
self.table_usage_request.set_table_name(table_name).set_start_time(
start_time).set_limit(limit)
if is_onprem():
self.assertRaises(OperationNotSupportedException,
self.handle.get_table_usage,
self.table_usage_request)
return
result = self.handle.get_table_usage(self.table_usage_request)
self._check_table_usage_result(result, limit if not_cloudsim() else 1,
start_time)
# set the start time in ISO 8601 formatted string and limit
start_str = (datetime.now() + timedelta(seconds=-240)).isoformat()
start_time = int(
mktime(
datetime.strptime(start_str,
'%Y-%m-%dT%H:%M:%S.%f').timetuple()) * 1000)
self.table_usage_request.set_start_time(start_str)
result = self.handle.get_table_usage(self.table_usage_request)
self._check_table_usage_result(result, limit if not_cloudsim() else 1,
start_time)
def testListTablesWithLimit(self):
# set limit = 2
last_returned_index = 2
part_table_names = [[
make_table_name('Users0'),
make_table_name('Users1')
], [make_table_name('Users0'),
make_table_name('Users1')]]
self.list_tables_request.set_limit(2)
for handle in range(self.num_handles):
result = self.handles[handle].list_tables(self.list_tables_request)
# TODO: add and use startIndex,numTables.
if not not_cloudsim():
self.assertEqual(result.get_tables(), part_table_names[handle])
self.assertEqual(result.get_last_returned_index(),
last_returned_index)
def check_table_result(self,
result,
state,
table_limits=None,
has_schema=True,
has_operation_id=True,
check_limit=True,
check_schema=True,
check_operation_id=True):
assert isinstance(self, TestCase)
# check compartment id
if (version is None or is_onprem() or version is not None
and is_cloudsim() and compare_version(version, '1.4.0') >= 0):
self.assertIsNone(result.get_compartment_id())
else:
self.assertEqual(result.get_compartment_id(), tenant_id)
# check table name
self.assertEqual(result.get_table_name(), table_name)
# check state
if isinstance(state, str):
self.assertEqual(result.get_state(), state)
else:
self.assertTrue(result.get_state() in state)
# check table limits
if check_limit:
if table_limits is None or is_onprem():
self.assertIsNone(result.get_table_limits())
else:
self.assertEqual(result.get_table_limits().get_read_units(),
table_limits.get_read_units())
self.assertEqual(result.get_table_limits().get_write_units(),
table_limits.get_write_units())
self.assertEqual(result.get_table_limits().get_storage_gb(),
table_limits.get_storage_gb())
# check table schema
# TODO: For on-prem proxy, TableResult.get_schema() always return None,
# This is a known bug, when it is fixed, the test should be change.
if check_schema and not_cloudsim() and not is_onprem():
(self.assertIsNotNone(result.get_schema())
if has_schema else self.assertIsNone(result.get_schema()))
# check operation id
if check_operation_id:
operation_id = result.get_operation_id()
(self.assertIsNotNone(operation_id)
if has_operation_id else self.assertIsNone(operation_id))
def testGetTableWithOperationId(self):
drop_request = TableRequest().set_statement(
'DROP TABLE IF EXISTS ' + table_name)
table_result = self.handle.table_request(drop_request)
self.get_table_request.set_table_name(table_name).set_operation_id(
table_result.get_operation_id())
result = self.handle.get_table(self.get_table_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(result.get_state(), State.DROPPING)
self.assertEqual(result.get_table_limits().get_read_units(),
table_limits.get_read_units())
self.assertEqual(result.get_table_limits().get_write_units(),
table_limits.get_write_units())
self.assertEqual(result.get_table_limits().get_storage_gb(),
table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(result.get_schema())
table_result.wait_for_state(self.handle, table_name, State.DROPPED,
wait_timeout, 1000)
def _check_table_usage_result(self,
result,
num_records,
start=0,
end=0,
check_separately=False):
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(len(result.get_usage_records()), num_records)
records = result.get_usage_records()
for count in range(len(records)):
start_time_res = records[count].get_start_time()
self.assertIsNotNone(start_time_res)
self.assertEqual(
records[count].get_start_time_string(),
datetime.fromtimestamp(float(start_time_res) /
1000).isoformat())
self.assertGreaterEqual(records[count].get_read_units(), 0)
self.assertGreaterEqual(records[count].get_write_units(), 0)
self.assertGreaterEqual(records[count].get_storage_gb(), 0)
if not_cloudsim():
# the record is generated during the time from start to end.
if check_separately:
self.assertGreater(start_time_res,
start + (count - 1) * 60000)
self.assertTrue(
records[count].get_seconds_in_period() in [0, 60])
else:
self.assertGreaterEqual(start_time_res,
start + count * 60000)
self.assertEqual(records[count].get_seconds_in_period(),
60)
end_time = start + (count + 1) * 60000
self.assertLessEqual(
start_time_res,
end_time if end == 0 else min(end_time, end))
self.assertEqual(records[count].get_read_throttle_count(), 0)
self.assertEqual(records[count].get_write_throttle_count(), 0)
self.assertEqual(records[count].get_storage_throttle_count(), 0)
def testTableRequestModifyTableLimits(self):
# create table before modifying the table limits
request = TableRequest().set_statement(
self.create_tb_statement).set_table_limits(self.table_limits)
self._do_table_request(request)
# modify the table limits
table_limits = TableLimits(10000, 10000, 100)
self.table_request.set_table_name(table_name).set_table_limits(
table_limits)
if is_onprem():
self.assertRaises(OperationNotSupportedException,
self.handle.table_request, self.table_request)
return
result = self.handle.table_request(self.table_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(result.get_state(), State.UPDATING)
if not_cloudsim():
self.assertIsNotNone(result.get_schema())
self.assertIsNotNone(result.get_operation_id())
self._wait_for_completion(result)
self.check_table_result(result, State.ACTIVE, table_limits)
# drop table after modifying the table limits
request.set_statement(self.drop_tb_statement)
self._do_table_request(request)
def testTableUsageWithEndTime(self):
# set a start time to avoid unexpected table usage information, and set
# the end time
current = int(round(time() * 1000))
start_time = current - 120000
end_time = current - 120000
self.table_usage_request.set_table_name(table_name).set_start_time(
start_time).set_end_time(end_time)
result = self.handle.get_table_usage(self.table_usage_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(len(result.get_usage_records()),
0 if not_cloudsim() else 1)
# set current time as end time
self.table_usage_request.set_end_time(current)
result = self.handle.get_table_usage(self.table_usage_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(len(result.get_usage_records()), 1)
for usage_record in result.get_usage_records():
start_time_res = usage_record.get_start_time()
self.assertEqual(
usage_record.get_start_time_string(),
datetime.fromtimestamp(float(start_time_res) /
1000).isoformat())
self.assertGreater(usage_record.get_read_units(), 0)
self.assertGreater(usage_record.get_write_units(), 0)
if not_cloudsim():
self.assertGreater(start_time_res, start_time)
self.assertLess(start_time_res, start_time + 60000)
self.assertLess(start_time_res, current)
self.assertEqual(usage_record.get_seconds_in_period(), 60)
self.assertLessEqual(usage_record.get_storage_gb(), 0)
self.assertEqual(usage_record.get_read_throttle_count(), 0)
self.assertEqual(usage_record.get_write_throttle_count(), 0)
self.assertEqual(usage_record.get_storage_throttle_count(), 0)
# set current time in ISO 8601 formatted string as end time
end_str = datetime.now().isoformat()
end_time = int(
mktime(
datetime.strptime(end_str, '%Y-%m-%dT%H:%M:%S.%f').timetuple())
* 1000)
self.table_usage_request.set_end_time(end_str)
result = self.handle.get_table_usage(self.table_usage_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(len(result.get_usage_records()), 1)
for usage_record in result.get_usage_records():
start_time_res = usage_record.get_start_time()
self.assertEqual(
usage_record.get_start_time_string(),
datetime.fromtimestamp(float(start_time_res) /
1000).isoformat())
self.assertGreater(usage_record.get_read_units(), 0)
self.assertGreater(usage_record.get_write_units(), 0)
if not_cloudsim():
self.assertGreater(start_time_res, start_time)
self.assertLess(start_time_res, start_time + 60000)
self.assertLess(start_time_res, end_time)
self.assertEqual(usage_record.get_seconds_in_period(), 60)
self.assertLessEqual(usage_record.get_storage_gb(), 0)
self.assertEqual(usage_record.get_read_throttle_count(), 0)
self.assertEqual(usage_record.get_write_throttle_count(), 0)
self.assertEqual(usage_record.get_storage_throttle_count(), 0)
def testTableRequestCreateDropIndex(self):
# create table before creating index
request = TableRequest().set_statement(
self.create_tb_statement).set_table_limits(self.table_limits)
result = self.handle.table_request(request)
result.wait_for_state(self.handle, table_name, State.ACTIVE,
wait_timeout, 1000)
# create index by resetting the statement
self.table_request.set_statement(self.create_idx_statement)
result = self.handle.table_request(self.table_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(result.get_state(), State.UPDATING)
self.assertEqual(result.get_table_limits().get_read_units(),
self.table_limits.get_read_units())
self.assertEqual(result.get_table_limits().get_write_units(),
self.table_limits.get_write_units())
self.assertEqual(result.get_table_limits().get_storage_gb(),
self.table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(result.get_schema())
wait_result = result.wait_for_state(self.handle, table_name,
State.ACTIVE, wait_timeout, 1000)
self.assertEqual(wait_result.get_table_name(), table_name)
self.assertEqual(wait_result.get_state(), State.ACTIVE)
self.assertEqual(wait_result.get_table_limits().get_read_units(),
self.table_limits.get_read_units())
self.assertEqual(wait_result.get_table_limits().get_write_units(),
self.table_limits.get_write_units())
self.assertEqual(wait_result.get_table_limits().get_storage_gb(),
self.table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(wait_result.get_schema())
self.assertIsNone(wait_result.get_operation_id())
# drop index by resetting the statement
self.table_request.set_statement(self.drop_idx_statement)
result = self.handle.table_request(self.table_request)
self.assertEqual(result.get_table_name(), table_name)
self.assertEqual(result.get_state(), State.UPDATING)
self.assertEqual(result.get_table_limits().get_read_units(),
self.table_limits.get_read_units())
self.assertEqual(result.get_table_limits().get_write_units(),
self.table_limits.get_write_units())
self.assertEqual(result.get_table_limits().get_storage_gb(),
self.table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(wait_result.get_schema())
wait_result = result.wait_for_state(self.handle, table_name,
State.ACTIVE, wait_timeout, 1000)
self.assertEqual(wait_result.get_table_name(), table_name)
self.assertEqual(wait_result.get_state(), State.ACTIVE)
self.assertEqual(wait_result.get_table_limits().get_read_units(),
self.table_limits.get_read_units())
self.assertEqual(wait_result.get_table_limits().get_write_units(),
self.table_limits.get_write_units())
self.assertEqual(wait_result.get_table_limits().get_storage_gb(),
self.table_limits.get_storage_gb())
if not_cloudsim():
self.assertIsNotNone(wait_result.get_schema())
self.assertIsNone(wait_result.get_operation_id())
# drop table after dropping index
self.table_request.set_statement(self.drop_tb_statement)
result = self.handle.table_request(self.table_request)
result.wait_for_state(self.handle, table_name, State.DROPPED,
wait_timeout, 1000)
