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)
class TestTableRequest(unittest.TestCase, TestBase): @classmethod def setUpClass(cls): TestBase.set_up_class() @classmethod def tearDownClass(cls): TestBase.tear_down_class() def setUp(self): TestBase.set_up(self) self.handle_config = get_handle_config(tenant_id) index_name = 'idx_' + table_name self.create_tb_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(4), 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 30 DAYS') self.create_idx_statement = ( 'CREATE INDEX ' + index_name + ' ON ' + table_name + '(fld_str, fld_double)') self.alter_fld_statement = ( 'ALTER TABLE ' + table_name + '(DROP fld_num)') self.alter_ttl_statement = ( 'ALTER TABLE ' + table_name + ' USING TTL 16 HOURS') self.drop_idx_statement = ( 'DROP INDEX ' + index_name + ' ON ' + table_name) self.drop_tb_statement = ('DROP TABLE IF EXISTS ' + table_name) self.table_request = TableRequest() self.table_limits = TableLimits(5000, 5000, 50) def tearDown(self): try: TableResult.wait_for_state(self.handle, table_name, State.ACTIVE, wait_timeout, 1000) drop_request = TableRequest().set_statement(self.drop_tb_statement) result = self.handle.table_request(drop_request) result.wait_for_state(self.handle, table_name, State.DROPPED, wait_timeout, 1000) except TableNotFoundException: pass finally: TestBase.tear_down(self) def testTableRequestSetIllegalStatement(self): self.table_request.set_statement('IllegalStatement') self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) self.table_request.set_statement( 'ALTER TABLE IllegalTable (DROP fld_num)') self.assertRaises(TableNotFoundException, self.handle.table_request, self.table_request) def testTableRequestSetIllegalTableLimits(self): self.assertRaises(IllegalArgumentException, self.table_request.set_table_limits, 'IllegalTableLimits') self.assertRaises(IllegalArgumentException, self.table_request.set_table_limits, None) self.table_request.set_statement( self.create_tb_statement).set_table_limits(TableLimits(5000, 0, 50)) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestSetIllegalTableName(self): self.assertRaises(IllegalArgumentException, self.table_request.set_table_name, {'name': table_name}) self.table_request.set_table_name( 'IllegalTable').set_table_limits(self.table_limits) self.assertRaises(TableNotFoundException, self.handle.table_request, self.table_request) def testTableRequestSetIllegalTimeout(self): self.assertRaises(IllegalArgumentException, self.table_request.set_timeout, 'IllegalTimeout') self.assertRaises(IllegalArgumentException, self.table_request.set_timeout, 0) self.assertRaises(IllegalArgumentException, self.table_request.set_timeout, -1) def testTableRequestSetIllegalDefaults(self): self.assertRaises(IllegalArgumentException, self.table_request.set_defaults, 'IllegalDefaults') def testTableRequestSetDefaults(self): self.table_request.set_defaults(self.handle_config) self.assertEqual(self.table_request.get_timeout(), table_request_timeout) def testTableRequestNoStatementAndTableName(self): self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestBothStatementAndTableName(self): self.table_request.set_statement( self.create_tb_statement).set_table_name(table_name) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestOnlyTableName(self): self.table_request.set_table_name(table_name) self.assertRaises(IllegalArgumentException, self.handle.table_request, self.table_request) def testTableRequestGets(self): self.table_request.set_table_name(table_name).set_statement( self.create_tb_statement).set_table_limits(self.table_limits) self.assertEqual(self.table_request.get_statement(), self.create_tb_statement) self.assertEqual(self.table_request.get_table_limits(), self.table_limits) self.assertEqual(self.table_request.get_table_name(), table_name) def testTableRequestIllegalRequest(self): self.assertRaises(IllegalArgumentException, self.handle.table_request, 'IllegalRequest') 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 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) def testTableRequestAlterTable(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 failed with TableLimits set request.set_statement(self.alter_fld_statement) self.assertRaises(IllegalArgumentException, self.handle.table_request, request) # alter table succeed without TableLimits set self.table_request.set_statement(self.alter_fld_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 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 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)