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)