def runTest(self): """ This function will fetch added event trigger under test database. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") func_name = self.function_info[1] func_response = trigger_funcs_utils.verify_trigger_function( self.server, self.db_name, func_name) if not func_response: raise Exception("Could not find the trigger function.") response = self.tester.get( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.event_trigger_id), content_type='html/json' ) self.assertEquals(response.status_code, 200)
def runTest(self): """ This function will add collation under schema node. """ schema_info = parent_node_dict["schema"][-1] server_id = schema_info["server_id"] db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add collation.") schema_id = self.schema_details[0] schema_name = self.schema_details[1] schema_response = schema_utils.verify_schemas(self.server, self.db_name, schema_name) if not schema_response: raise Exception("Could not find the schema to add the collation.") data = { "copy_collation": "pg_catalog.\"C\"", "name": "collation_add_%s" % str(uuid.uuid4())[1:8], "owner": self.server["username"], "schema": schema_name } response = self.tester.post(self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(schema_id) + '/', data=json.dumps(data), content_type='html/json') self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)
def runTest(self): """ This function will add domain under schema node. """ db_id = self.database_info["db_id"] server_id = self.database_info["server_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to get the domain.") db_name = self.database_info["db_name"] schema_response = schema_utils.verify_schemas(self.server, db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to get the domain.") domain_id = self.domain_info[0] # Call GET API to verify the domain get_response = self.tester.delete( self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(self.schema_id) + '/' + str(domain_id), content_type='html/json') self.assertEquals(get_response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)
def setUp(self): super(CheckConstraintAddTestCase, self).setUp() self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a check " "constraint.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add a check " "constraint.") self.table_name = "table_checkconstraint_add_%s" % \ (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name)
def setUp(self): self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] server_response = server_utils.connect_server(self, self.server_id) if server_response["data"]["version"] < 90300 and "mview" in self.url: message = "Materialized Views are not supported by PG9.2 " \ "and PPAS9.2 and below." self.skipTest(message) db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to update a view.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to update a view.") self.view_id = views_utils.create_view(self.server, self.db_name, self.schema_name, self.sql_query, self.view_name)
def setUp(self): self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a table.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add a table.") self.is_partition = False if hasattr(self, 'server_min_version'): server_con = server_utils.connect_server(self, self.server_id) if not server_con["info"] == "Server connected.": raise Exception("Could not connect to server to add " "partitioned table.") if server_con["data"]["version"] < self.server_min_version: message = "Partitioned table are not supported by " \ "PPAS/PG 10.0 and below." self.skipTest(message) else: self.is_partition = True
def setUp(self): super(TriggersDeleteTestCase, self).setUp() self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to delete trigger.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to delete trigger.") self.table_name = "table_trigger_%s" % (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) self.func_name = "trigger_func_delete_%s" % str(uuid.uuid4())[1:8] self.function_info = \ trigger_funcs_utils.create_trigger_function_with_trigger( self.server, self.db_name, self.schema_name, self.func_name) self.trigger_name = "test_trigger_delete_%s" % (str(uuid.uuid4())[1:8]) self.trigger_id = triggers_utils.create_trigger(self.server, self.db_name, self.schema_name, self.table_name, self.trigger_name, self.func_name)
def setUp(self): super(SynonymAddTestCase, self).setUp() self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] server_con = server_utils.connect_server(self, self.server_id) if server_con: if "type" in server_con["data"]: if server_con["data"]["type"] == "pg": message = "Synonyms are not supported by PG." self.skipTest(message) db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add synonym.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add the synonym.") self.sequence_name = "test_sequence_synonym_%s" % \ str(uuid.uuid4())[1:8] self.sequence_id = sequence_utils.create_sequences( self.server, self.db_name, self.schema_name, self.sequence_name)
def setUp(self): self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception( "Could not connect to database to delete a foreign " "key constraint.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to delete a foreign " "key constraint.") self.local_table_name = "local_table_foreignkey_delete_%s" % \ (str(uuid.uuid4())[1:8]) self.local_table_id = tables_utils.create_table( self.server, self.db_name, self.schema_name, self.local_table_name) self.foreign_table_name = "foreign_table_foreignkey_delete_%s" % \ (str(uuid.uuid4())[1:8]) self.foreign_table_id = tables_utils.create_table( self.server, self.db_name, self.schema_name, self.foreign_table_name) self.foreign_key_name = "test_foreignkey_delete_%s" % \ (str(uuid.uuid4())[1:8]) self.foreign_key_id = fk_utils.create_foreignkey( self.server, self.db_name, self.schema_name, self.local_table_name, self.foreign_table_name)
def runTest(self): """ This function will delete FTS template present under test schema. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") fts_response = fts_temp_utils.verify_fts_template(self.server, self.db_name, self.fts_temp_name) if not fts_response: raise Exception("Could not find the FTS template.") delete_response = self.tester.delete( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/' + str(self.fts_temp_id), follow_redirects=True) self.assertEquals(delete_response.status_code, 200)
def runTest(self): """ This function will delete collation under schema node. """ server_id = self.schema_info["server_id"] db_id = self.schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") collation_id = self.collation[0] schema_id = self.schema_info["schema_id"] get_response = self.tester.delete( self.url + str(utils.SERVER_GROUP) + '/' + str( server_id) + '/' + str(db_id) + '/' + str(schema_id) + '/' + str(collation_id), content_type='html/json') self.assertEquals(get_response.status_code, 200) # Disconnect database to delete it database_utils.disconnect_database(self, server_id, db_id)
def setUp(self): self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to delete rule.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to delete rule.") self.table_name = "table_column_%s" % (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) self.rule_name = "test_rule_delete_%s" % (str(uuid.uuid4())[1:8]) self.rule_id = rules_utils.create_rule(self.server, self.db_name, self.schema_name, self.table_name, self.rule_name)
def set_up(obj): """Common set up function""" from regression import parent_node_dict obj.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] obj.server_id = schema_info["server_id"] obj.db_id = schema_info["db_id"] obj.prorettypename = "event_trigger/trigger" server_con = server_utils.connect_server(obj, obj.server_id) if not server_con["info"] == "Server connected.": raise Exception("Could not connect to server.") if "version" in server_con["data"]: obj.server_version = server_con["data"]["version"] if server_con["data"]["version"] < 90300: obj.prorettypename = "trigger" if "type" in server_con["data"]: obj.server_type = server_con["data"]["type"] db_con = database_utils.connect_database(obj, utils.SERVER_GROUP, obj.server_id, obj.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") obj.schema_id = schema_info["schema_id"] obj.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(obj.server, obj.db_name, obj.schema_name) if not schema_response: raise Exception("Could not find the schema.") return obj
def runTest(self): """ This function will add new FTS configuration under test schema. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") self.fts_conf_name = "fts_conf_%s" % str(uuid.uuid4())[1:8] data = \ { "name": self.fts_conf_name, "owner": self.server["username"], "prsname": "%s.%s" % (self.schema_name, self.fts_parser_name), "schema": self.schema_id, "tokens": [] } response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(data), content_type='html/json') self.assertEquals(response.status_code, 200)
def runTest(self): """ This function will update domain under schema node. """ db_id = self.database_info["db_id"] server_id = self.database_info["server_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to get the domain.") db_name = self.database_info["db_name"] schema_response = schema_utils.verify_schemas(self.server, db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to get the domain.") domain_response = domain_utils.verify_domain(self.server, db_name, self.schema_id, self.domain_name) if not domain_response: raise Exception("Could not find the domain to update.") domain_id = self.domain_info[0] data = {"description": "This is domain update comment", "id": domain_id, } response = self.tester.put( self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(self.schema_id) + '/' + str(domain_id), data=json.dumps(data), follow_redirects=True) self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)
def runTest(self): """ This function will update event trigger under test database. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") func_name = self.function_info[1] func_response = trigger_funcs_utils.verify_trigger_function( self.server, self.db_name, func_name) if not func_response: raise Exception("Could not find the trigger function.") trigger_response = event_trigger_utils.verify_event_trigger( self.server, self.db_name, self.trigger_name) if not trigger_response: raise Exception("Could not find event trigger.") data = { "comment": "This is event trigger update comment", "id": self.event_trigger_id } put_response = self.tester.put( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.event_trigger_id), data=json.dumps(data), follow_redirects=True) self.assertEquals(put_response.status_code, 200)
def runTest(self): """ This function will fetch FTS template present under test schema. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") response = self.tester.get(self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/' + str(self.fts_temp_id), content_type='html/json') self.assertEquals(response.status_code, 200)
def runTest(self): """This function will add sequence(s) under schema node.""" db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add sequence.") schema_id = schema_info["schema_id"] schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, db_name, schema_name) if not schema_response: raise Exception("Could not find the schema to add sequence.") db_user = self.server["username"] common_data = { "relacl": [ { "grantee": db_user, "grantor": db_user, "privileges": [ { "privilege_type": "r", "privilege": True, "with_grant": True }, { "privilege_type": "w", "privilege": True, "with_grant": False }, { "privilege_type": "U", "privilege": True, "with_grant": False } ] } ], "schema": schema_name, "seqowner": db_user, } self.data.update(common_data) response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(schema_id) + '/', data=json.dumps(self.data), content_type='html/json') self.assertEquals(response.status_code, 200)
def runTest(self): """ This function will update trigger function under database node. """ schema_info = parent_node_dict["schema"][-1] server_id = schema_info["server_id"] db_id = schema_info["db_id"] func_name = "test_event_put_%s" % str(uuid.uuid4())[1:8] server_con = server_utils.connect_server(self, server_id) if not server_con["info"] == "Server connected.": raise Exception("Could not connect to server to add resource " "groups.") server_version = 0 if "type" in server_con["data"]: if server_con["data"]["version"] < 90300: server_version = server_con["data"]["version"] self.function_info = trigger_funcs_utils.create_trigger_function( self.server, self.db_name, self.schema_name, func_name, server_version) db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add collation.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add the collation.") func_name = self.function_info[1] func_response = trigger_funcs_utils.verify_trigger_function( self.server, self.db_name, func_name) if not func_response: raise Exception("Could not find the trigger function to update" " it's details.") trigger_func_id = self.function_info[0] data = { "description": "This is trigger function update comment", "id": trigger_func_id } put_response = self.tester.put( self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(self.schema_id) + '/' + str(trigger_func_id), data=json.dumps(data), follow_redirects=True) self.assertEquals(put_response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)
def setUp(self): self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a type.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add a type.")
def runTest(self): """ This function will add new FTS dictionary under test schema. """ self.schema_data = parent_node_dict['schema'][-1] self.schema_name = self.schema_data['schema_name'] self.schema_id = self.schema_data['schema_id'] self.server_id = self.schema_data['server_id'] self.db_id = self.schema_data['db_id'] self.db_name = parent_node_dict["database"][-1]["db_name"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") self.fts_dict_name = "fts_dict_%s" % str(uuid.uuid4())[1:8] data = \ { "name": self.fts_dict_name, "options": [ { "value": "synonym_sample", "option": "synonyms" } ], "owner": self.server["username"], "schema": self.schema_id, "template": "synonym" } response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(data), content_type='html/json') self.assertEquals(response.status_code, 200)
def runTest(self): """ This function will fetch added event trigger under test database. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") func_name = self.function_info[1] func_response = trigger_funcs_utils.verify_trigger_function( self.server, self.db_name, func_name) if not func_response: raise Exception("Could not find the trigger function.") actual_response_code = True expected_response_code = False if self.is_positive_test: if hasattr(self, "event_trigger_list"): response = self.get_event_trigger_list() else: response = self.get_event_trigger() actual_response_code = response.status_code expected_response_code = self.expected_data['status_code'] else: if hasattr(self, "error_fetching_event_trigger"): with patch(self.mock_data["function_name"], return_value=eval(self.mock_data["return_value"])): if hasattr(self, "event_trigger_list"): response = self.get_event_trigger_list() else: response = self.get_event_trigger() actual_response_code = response.status_code expected_response_code = self.expected_data['status_code'] if hasattr(self, "wrong_event_trigger_id"): self.event_trigger_id = 99999 response = self.get_event_trigger() actual_response_code = response.status_code expected_response_code = self.expected_data['status_code'] self.assertEqual(actual_response_code, expected_response_code)
def setUp(self): super(CheckConstraintGetNodesTestCase, self).setUp() # Load test data self.data = self.test_data # Create db connection self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to fetch a check " "constraint.") # Create schema self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to fetch a check " "constraint.") # Create table self.table_name = "table_checkconstraint_get_%s" % \ (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) # Create constraint if 'query' in self.inventory_data: query = self.inventory_data['query'] else: query = None self.check_constraint_name = "test_checkconstraint_get_%s" % \ (str(uuid.uuid4())[1:8]) self.check_constraint_id = \ check_constraint_utils.create_check_constraint( self.server, self.db_name, self.schema_name, self.table_name, self.check_constraint_name, query)
def setUp(self): super(CompoundTriggersGetTestCase, self).setUp() self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] server_con = server_utils.connect_server(self, self.server_id) if server_con: if "type" in server_con["data"]: if server_con["data"]["type"] == "pg": message = "Compound Triggers are not supported by PG." self.skipTest(message) elif server_con["data"]["type"] == "ppas" and \ server_con["data"]["version"] < 120000: message = "Compound Triggers are not supported by " \ "EPAS server less than 12" self.skipTest(message) db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception( "Could not connect to database to update a compound trigger.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to update a trigger.") self.table_name = \ "table_compound_trigger_%s" % (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) self.trigger_name = \ "test_compound_trigger_update_%s" % (str(uuid.uuid4())[1:8]) self.trigger_id = \ compound_triggers_utils.create_compound_trigger(self.server, self.db_name, self.schema_name, self.table_name, self.trigger_name)
def setUp(self): # Load test data self.data = self.test_data # Create db connection self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to fetch a foreign " "key constraint.") # Create schema self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to fetch a foreign " "key constraint.") # Create local table self.local_table_name = "local_table_foreignkey_get_%s" % \ (str(uuid.uuid4())[1:8]) self.local_table_id = tables_utils.create_table( self.server, self.db_name, self.schema_name, self.local_table_name) # Create foreign table self.foreign_table_name = "foreign_table_foreignkey_get_%s" % \ (str(uuid.uuid4())[1:8]) self.foreign_table_id = tables_utils.create_table( self.server, self.db_name, self.schema_name, self.foreign_table_name) # Create foreign key self.foreign_key_name = "test_foreignkey_get_%s" % \ (str(uuid.uuid4())[1:8]) self.foreign_key_id = fk_utils.create_foreignkey( self.server, self.db_name, self.schema_name, self.local_table_name, self.foreign_table_name)
def runTest(self): """ This function will add a new FTS parser under test schema. """ self.schema_data = parent_node_dict['schema'][-1] self.schema_name = self.schema_data['schema_name'] self.schema_id = self.schema_data['schema_id'] self.server_id = self.schema_data['server_id'] self.db_id = self.schema_data['db_id'] self.db_name = parent_node_dict["database"][-1]["db_name"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") self.fts_parser_name = "fts_parser_%s" % str(uuid.uuid4())[1:8] self.data = \ { "name": self.fts_parser_name, "schema": self.schema_id, "prsend": "prsd_end", "prsheadline": "prsd_headline", "prslextype": "dsynonym_init", "prsstart": "prsd_start", "prstoken": "prsd_nexttoken" } response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(self.data), content_type='html/json') self.assertEquals(response.status_code, 200)
def setUp(self): self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a table.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add a table.") self.table_name = "test_table_put_%s" % (str(uuid.uuid4())[1:8]) self.is_partition = False if hasattr(self, 'server_min_version'): server_con = server_utils.connect_server(self, self.server_id) if not server_con["info"] == "Server connected.": raise Exception("Could not connect to server to add " "partitioned table.") if server_con["data"]["version"] < self.server_min_version: message = "Partitioned table are not supported by " \ "PPAS/PG 10.0 and below." self.skipTest(message) else: self.is_partition = True self.table_id = tables_utils.create_table_for_partition( self.server, self.db_name, self.schema_name, self.table_name, 'partitioned', self.partition_type) else: self.table_id = tables_utils.create_table( self.server, self.db_name, self.schema_name, self.table_name)
def runTest(self): """ This function will update FTS dictionary present under test schema. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") dict_response = fts_dict_utils.verify_fts_dict(self.server, self.db_name, self.fts_dict_name) if not dict_response: raise Exception("Could not find the FTS dictionary.") dict_response = fts_dict_utils.verify_fts_dict(self.server, self.db_name, self.fts_dict_name_1) if not dict_response: raise Exception("Could not find the FTS dictionary.") data = {'ids': self.fts_dict_ids} delete_response = self.tester.delete( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(data), content_type='html/json', follow_redirects=True) self.assertEquals(delete_response.status_code, 200)
def runTest(self): """ This function will delete FTS parser present under test schema. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") parser_response = fts_parser_utils.verify_fts_parser( self.server, self.db_name, self.fts_parser_name) if not parser_response: raise Exception("Could not find the FTS parser.") delete_response = self.tester.delete( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/' + str(self.fts_parser_id), follow_redirects=True) self.assertEqual(delete_response.status_code, 200) negative_delete_response = self.tester.delete( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/' + str(0), follow_redirects=True) self.assertEqual(negative_delete_response.status_code, 500)
def runTest(self): """ This function will add collation under schema node. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add collation.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add the collation.") self.test_data['copy_collation'] = "pg_catalog.\"C\"" self.test_data['name'] = "collation_add_%s" % str(uuid.uuid4())[1:8] self.test_data['owner'] = self.server["username"] self.test_data['schema'] = self.schema_name if self.is_positive_test: response = self.create_collation() else: if hasattr(self, "parameter_missing"): del self.test_data['name'] response = self.create_collation() if hasattr(self, "error_incomplete_definition"): del self.test_data['copy_collation'] response = self.create_collation() if hasattr(self, "error_getting_collation_oid"): with patch(self.mock_data["function_name"], side_effect=eval(self.mock_data["return_value"])): response = self.create_collation() if hasattr(self, "internal_server_error"): return_value_object = eval(self.mock_data["return_value"]) with patch(self.mock_data["function_name"], side_effect=[return_value_object]): response = self.create_collation() actual_response_code = response.status_code expected_response_code = self.expected_data['status_code'] self.assertEqual(actual_response_code, expected_response_code)
def setUp(self): # Load test data self.data = self.test_data # Create db connection self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a table.") # Create schema self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add a table.") # Create table self.table_name = "table_exclusion_%s" % (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) # Create constraint to fetch self.exclusion_constraint_name = \ "test_exclusion_delete_%s" % (str(uuid.uuid4())[1:8]) self.exclusion_constraint_id = exclusion_utils. \ create_exclusion_constraint(self.server, self.db_name, self.schema_name, self.table_name, self.exclusion_constraint_name) # Cross check constraint creation cross_check_res = exclusion_utils.verify_exclusion_constraint( self.server, self.db_name, self.exclusion_constraint_name) if not cross_check_res: raise Exception("Could not find the exclusion constraint " "to delete.")
def runTest(self): """ This function will add domain under schema node. """ db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add collation.") schema_id = schema_info["schema_id"] schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, db_name, schema_name) if not schema_response: raise Exception("Could not find the schema to add the collation.") data = { "basensp": schema_name, "basetype": "character", "collname": "pg_catalog.\"POSIX\"", "constraints": [{ "conname": "num", "convalidated": True }], "is_tlength": True, "max_val": 2147483647, "min_val": 1, "name": "domain_add_%s" % (str(uuid.uuid4())[1:8]), "owner": self.server["username"], "seclabels": [], "typdefault": "1", "typlen": "10" } # Call POST API to add domain response = self.tester.post(self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str( self.db_id) + '/' + str(schema_id) + '/', data=json.dumps(data), content_type='html/json') self.assertEquals(response.status_code, 200)
def runTest(self): """ This function will add collation under schema node. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") self.collation_id = self.collation[0] if self.is_positive_test: response = self.get_dependency_dependent() actual_response_code = response.status_code expected_response_code = self.expected_data['status_code'] self.assertEqual(actual_response_code, expected_response_code)
def setUp(self): # Load test data self.data = self.test_data # Create db connection self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a table.") # Create schema self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add a table.") # Create table self.table_name = "table_column_%s" % (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) # Create column self.column_name = self.inventory_data["name"] + \ (str(uuid.uuid4())[1:8]) col_data_type = self.inventory_data["data_type"] self.column_id = columns_utils.create_column(self.server, self.db_name, self.schema_name, self.table_name, self.column_name, col_data_type) col_response = columns_utils.verify_column(self.server, self.db_name, self.column_name) if not col_response: raise Exception("Could not find the column to update.")
def setUp(self): self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add sequence.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add sequence.") self.sequence_name = "test_sequence_delete_%s" % str(uuid.uuid4())[1:8] self.sequence_id = sequence_utils.create_sequences( self.server, self.db_name, self.schema_name, self.sequence_name)
def runTest(self): """ This function will add new FTS dictionary under test schema. """ self.schema_data = parent_node_dict['schema'][-1] self.schema_name = self.schema_data['schema_name'] self.schema_id = self.schema_data['schema_id'] self.server_id = self.schema_data['server_id'] self.db_id = self.schema_data['db_id'] self.db_name = parent_node_dict["database"][-1]["db_name"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") self.fts_dict_name = "fts_dict_%s" % str(uuid.uuid4())[1:8] data = \ { "name": self.fts_dict_name, "options": [ { "value": "synonym_sample", "option": "synonyms" } ], "owner": self.server["username"], "schema": self.schema_id, "template": "synonym" } response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(data), content_type='html/json') self.assertEquals(response.status_code, 200)
def runTest(self): """ This function will add domain under schema node. """ db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add collation.") schema_id = schema_info["schema_id"] schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, db_name, schema_name) if not schema_response: raise Exception("Could not find the schema to add the collation.") data = { "basensp": schema_name, "basetype": "character", "constraints": [{ "conname": "num", "convalidated": True }], "is_tlength": True, "max_val": 2147483647, "min_val": 1, "name": "domain_add_%s" % (str(uuid.uuid4())[1:8]), "owner": self.server["username"], "seclabels": [], "typdefault": "1", "typlen": "10" } # Call POST API to add domain response = self.tester.post(self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(schema_id) + '/', data=json.dumps(data), content_type='html/json') self.assertEquals(response.status_code, 200)
def runTest(self): """ This function will add domain constraint under test database. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") self.test_data['name'] =\ "test_domain_con_add_%s" % (str(uuid.uuid4())[1:8]) self.domain_id = self.domain_info[0] if self.is_positive_test: response = self.create_domain_constraint() else: if hasattr(self, "internal_server_error"): return_value_object = eval(self.mock_data["return_value"]) with patch(self.mock_data["function_name"], side_effect=[return_value_object]): response = self.create_domain_constraint() if hasattr(self, "error_in_db"): return_value_object = eval(self.mock_data["return_value"]) with patch(self.mock_data["function_name"], side_effect=[return_value_object]): response = self.create_domain_constraint() if hasattr(self, "error_getting_coid"): with patch(self.mock_data["function_name"], side_effect=eval(self.mock_data["return_value"])): response = self.create_domain_constraint() if hasattr(self, "error_domain_id"): self.domain_id = 99999 response = self.create_domain_constraint() actual_response_code = response.status_code expected_response_code = self.expected_data['status_code'] self.assertEqual(actual_response_code, expected_response_code)
def runTest(self): """ This function will add domain constraint under test database. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") self.domain_id = self.domain_info[0] domain_response = domain_cons_utils.verify_domain( self.server, self.db_name, self.schema_id, self.domain_name) if not domain_response: raise Exception("Could not find the domain.") domain_cons_response = domain_cons_utils.verify_domain_constraint( self.server, self.db_name, self.domain_con_name) if not domain_cons_response: raise Exception("Could not find domain constraint.") if self.is_positive_test: response = self.delete_domain_constraint() else: if hasattr(self, "error_deleting_domain_constraints"): with patch(self.mock_data["function_name"], return_value=eval(self.mock_data["return_value"])): response = self.delete_domain_constraint() if hasattr(self, "wrong_domain_constraint_id"): self.domain_constraint_id = 99999 response = self.delete_domain_constraint() actual_response_code = response.status_code expected_response_code = self.expected_data['status_code'] self.assertEquals(actual_response_code, expected_response_code)
def runTest(self): """ This function will update new FTS configuration under test schema. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") fts_conf_response = fts_configuration_utils.verify_fts_configuration( self.server, self.db_name, self.fts_conf_name) if not fts_conf_response: raise Exception("Could not find the FTS Configuration.") data = \ { "description": "This is FTS configuration update comment", "id": self.fts_conf_id } put_response = self.tester.put( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/' + str(self.fts_conf_id), data=json.dumps(data), follow_redirects=True) self.assertEquals(put_response.status_code, 200) negative_put_response = self.tester.put( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/' + str(0), data=json.dumps(data), follow_redirects=True) self.assertEquals(negative_put_response.status_code, 500)
def setUp(self): super(CompoundTriggersAddTestCase, self).setUp() self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] server_con = server_utils.connect_server(self, self.server_id) if server_con: if "type" in server_con["data"]: if server_con["data"]["type"] == "pg": message = "Compound Triggers are not supported by PG." self.skipTest(message) elif server_con["data"]["type"] == "ppas" \ and server_con["data"]["version"] < 120000: message = "Compound Triggers are not supported by " \ "EPAS server less than 12" self.skipTest(message) db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a trigger.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception( "Could not find the schema to add a compound trigger.") self.table_name = \ "table_compound_trigger_%s" % (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) view_sql = "CREATE OR REPLACE VIEW %s.%s AS SELECT 'Hello World'; " \ "ALTER TABLE %s.%s OWNER TO %s" self.view_name = \ "view_compound_trigger_%s" % (str(uuid.uuid4())[1:8]) self.view_id = compound_trigger_utils.create_view( self.server, self.db_name, self.schema_name, view_sql, self.view_name)
def setUp(self): # Load test data self.data = self.test_data # Update url self.url = self.url + self.add_to_url # Create db connection self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] # Check Server version if "server_min_version" in self.inventory_data: server_con = server_utils.connect_server(self, self.server_id) if not server_con["info"] == "Server connected.": raise Exception("Could not connect to server to add " "partitioned table.") if server_con["data"]["version"] < \ self.inventory_data["server_min_version"]: self.skipTest(self.inventory_data["skip_msg"]) db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a table.") # Create schema self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add a table.") # Create table self.table_name = "test_table_get_%s" % (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name)
def runTest(self): """ This function will add FTS template present under test schema. """ self.schema_data = parent_node_dict['schema'][-1] self.schema_name = self.schema_data['schema_name'] self.schema_id = self.schema_data['schema_id'] self.server_id = self.schema_data['server_id'] self.db_id = self.schema_data['db_id'] self.db_name = parent_node_dict["database"][-1]["db_name"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") self.fts_template_name = "fts_temp_%s" % str(uuid.uuid4())[1:8] self.data = \ { "name": self.fts_template_name, "schema": self.schema_id, "tmplinit": "dispell_init", "tmpllexize": "dispell_lexize" } response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(self.data), content_type='html/json') self.assertEqual(response.status_code, 200)
def setUp(self): """ Creating index required in further steps""" self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a table.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add a table.") self.table_name = "table_column_%s" % (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) self.column_name = "test_column_delete_%s" % (str(uuid.uuid4())[1:8]) self.column_id = columns_utils.create_column(self.server, self.db_name, self.schema_name, self.table_name, self.column_name) self.index_name = "test_index_delete_%s" % (str(uuid.uuid4())[1:8]) self.index_id = indexes_utils.create_index(self.server, self.db_name, self.schema_name, self.table_name, self.index_name, self.column_name) if self.is_list: self.index_name_1 = "test_index_delete_%s" % (str( uuid.uuid4())[1:8]) self.index_ids = [ self.index_id, indexes_utils.create_index(self.server, self.db_name, self.schema_name, self.table_name, self.index_name_1, self.column_name) ]
def setUp(self): super(SequenceDeleteTestCase, self).setUp() self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add sequence.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add sequence.") self.sequence_name = "test_sequence_delete_%s" % str(uuid.uuid4())[1:8] self.sequence_id = sequence_utils.create_sequences( self.server, self.db_name, self.schema_name, self.sequence_name)
def runTest(self): db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add domain.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add the domain.") self.domain_id = self.domain_info[0] if self.is_positive_test: with patch(self.mock_data["function_name"], return_value=eval(self.mock_data["return_value"])): response = self.msql_domain() actual_response_code = response.status_code expected_response_code = self.expected_data['status_code'] self.assertEqual(actual_response_code, expected_response_code)
def setUp(self): # Load test data self.data = self.test_data # Create db connection self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a " "index constraint(primary key or unique key).") # Create schema self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add a index " "constraint(primary key or unique key).") # Create table self.table_name = "table_indexconstraint_%s" % \ (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) # Create constraint self.constraint_name = self.inventory_data["constraint_name"] + \ (str(uuid.uuid4())[1:8]) self.type = self.inventory_data["type"] self.index_constraint_id = index_constraint_utils. \ create_index_constraint(self.server, self.db_name, self.schema_name, self.table_name, self.constraint_name, self.type)
def setUp(self): self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] self.server_version = schema_info["server_version"] if self.server_version < 99999: self.skipTest( "Logical replication is not supported " "for server version less than 10" ) db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception( "Could not connect to database to delete publication.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to delete publication.") self.table_name = "table_column_%s" % (str(uuid.uuid4())[1:8]) self.server_version = schema_info["server_version"] if self.server_version < 99999: self.skipTest( "Logical replication is not supported " "for server version less than 10" ) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) self.publication_name = "test_publication_update_%s" % ( str(uuid.uuid4())[1:8]) self.publication_id = \ publication_utils.create_publication(self.server, self.db_name, self.publication_name)
def runTest(self): """ This function will update collation under schema node. """ # Verify database db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") # Verify schema schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") # Verify collation coll_name = self.collation[1] collation_response = collation_utils.verify_collation(self.server, self.db_name, coll_name) if not collation_response: raise Exception("Could not find the collation.") self.collation_id = self.collation[0] self.test_data['id'] = self.collation_id if self.is_positive_test: put_response = self.update_collation() else: if hasattr(self, "error_updating_collation"): with patch(self.mock_data["function_name"], return_value=eval(self.mock_data["return_value"])): put_response = self.update_collation() if hasattr(self, "internal_server_error"): with patch(self.mock_data["function_name"], return_value=eval(self.mock_data["return_value"])): put_response = self.update_collation() actual_response_code = put_response.status_code expected_response_code = self.expected_data['status_code'] self.assertEqual(actual_response_code, expected_response_code)
def runTest(self): """ This function will add new FTS templates under test schema. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") fts_dict_response = fts_templates_utils.verify_fts_template( self.server, self.db_name, self.fts_templates_name ) if not fts_dict_response: raise Exception("Could not find the FTS Templates.") if self.is_positive_test: if hasattr(self, "node"): response = self.get_fts_templates_node() else: response = self.get_fts_templates_nodes() else: if hasattr(self, "error_fetching_fts_template"): with patch(self.mock_data["function_name"], return_value=eval(self.mock_data["return_value"])): if hasattr(self, "node"): response = self.get_fts_templates_node() else: response = self.get_fts_templates_nodes() actual_response_code = response.status_code expected_response_code = self.expected_data['status_code'] self.assertEqual(actual_response_code, expected_response_code)
def runTest(self): """ This function will update FTS parser present under test schema. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") parser_response = fts_parser_utils.verify_fts_parser( self.server, self.db_name, self.fts_parser_name) if not parser_response: raise Exception("Could not find the FTS parser.") data = \ { "description": "This is FTS parser update comment", "id": self.fts_parser_id } put_response = self.tester.put( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/' + str(self.fts_parser_id), data=json.dumps(data), follow_redirects=True) self.assertEquals(put_response.status_code, 200)
def setUp(self): # Load test data self.data = self.test_data # Create db connection self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a table.") # Create schema self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add a table.") # Create table self.table_name = "test_table_delete_%s" % (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) # Create table if self.is_list: self.table_name_1 = \ "test_table_delete_%s" % (str(uuid.uuid4())[1:8]) self.table_id_1 = tables_utils.create_table( self.server, self.db_name, self.schema_name, self.table_name_1) # Verify table creation table_response = tables_utils.verify_table(self.server, self.db_name, self.table_id) if not table_response: raise Exception("Could not find the table to delete.")
def runTest(self): """ This function will update collation under schema node. """ server_id = self.schema_info["server_id"] db_id = self.schema_info["db_id"] # Verify database db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") # Verify schema schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") # Verify collation coll_name = self.collation[1] collation_response = collation_utils.verify_collation(self.server, self.db_name, coll_name) if not collation_response: raise Exception("Could not find the collation.") collation_id = self.collation[0] schema_id = self.schema_info["schema_id"] data = { "description": "This is collation update comment", "id": collation_id } put_response = self.tester.put(self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(schema_id) + '/' + str(collation_id), data=json.dumps(data), follow_redirects=True) self.assertEquals(put_response.status_code, 200) # Disconnect database to delete it database_utils.disconnect_database(self, server_id, db_id)
def setUp(self): super(TriggersDeleteMultipleTestCase, self).setUp() self.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] self.server_id = schema_info["server_id"] self.db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to delete trigger.") self.schema_id = schema_info["schema_id"] self.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to delete trigger.") self.table_name = "table_trigger_%s" % (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) self.func_name = "trigger_func_delete_%s" % str(uuid.uuid4())[1:8] self.function_info = \ trigger_funcs_utils.create_trigger_function_with_trigger( self.server, self.db_name, self.schema_name, self.func_name) self.trigger_name = "test_trigger_delete_%s" % (str(uuid.uuid4())[1:8]) self.trigger_name_1 = "test_trigger_delete_%s" %\ (str(uuid.uuid4())[1:8]) self.trigger_ids = [triggers_utils.create_trigger(self.server, self.db_name, self.schema_name, self.table_name, self.trigger_name, self.func_name), triggers_utils.create_trigger(self.server, self.db_name, self.schema_name, self.table_name, self.trigger_name_1, self.func_name) ]
def runTest(self): """ This function will add package under test schema. """ db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.server_id, self.db_id) if not db_con["info"] == "Database connected.": raise Exception("Could not connect to database.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema.") data = \ { "name": "pkg_%s" % str(uuid.uuid4())[1:8], "owner": self.server["username"], "pkgacl": [], "pkgbodysrc": "PROCEDURE p1() is \n" "begin \n" "dbms_output.put_line('Test_pkg.Proc...'); " "\nEND\t;", "pkgheadsrc": "PROCEDURE p1();", "schema": self.schema_id } response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/' + str(self.schema_id) + '/', data=json.dumps(data), content_type='html/json') self.assertEquals(response.status_code, 200)
def runTest(self): """ This function will delete trigger function under database node. """ schema_info = parent_node_dict["schema"][-1] server_id = schema_info["server_id"] db_id = schema_info["db_id"] func_name = "test_event_delete_%s" % str(uuid.uuid4())[1:8] server_con = server_utils.connect_server(self, server_id) if not server_con["info"] == "Server connected.": raise Exception("Could not connect to server to add resource " "groups.") server_version = 0 if "type" in server_con["data"]: if server_con["data"]["version"] < 90300: server_version = server_con["data"]["version"] self.function_info = trigger_funcs_utils.create_trigger_function( self.server, self.db_name, self.schema_name, func_name, server_version) db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add collation.") schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise Exception("Could not find the schema to add the collation.") trigger_func_id = self.function_info[0] response = self.tester.delete( self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(self.schema_id) + '/' + str(trigger_func_id), content_type='html/json' ) self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)
def setUpClass(cls): cls.db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] cls.server_id = schema_info["server_id"] cls.db_id = schema_info["db_id"] db_con = database_utils.connect_database(cls, utils.SERVER_GROUP, cls.server_id, cls.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a " "index constraint(primary key or unique key).") cls.schema_id = schema_info["schema_id"] cls.schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(cls.server, cls.db_name, cls.schema_name) if not schema_response: raise Exception("Could not find the schema to add a index " "constraint(primary key or unique key).") cls.table_name = "table_indexconstraint_%s" % \ (str(uuid.uuid4())[1:8]) cls.table_id = tables_utils.create_table(cls.server, cls.db_name, cls.schema_name, cls.table_name)
def runTest(self): """ This function will add trigger function under schema node. """ super(TriggerFuncAddTestCase, self).runTest() db_name = parent_node_dict["database"][-1]["db_name"] schema_info = parent_node_dict["schema"][-1] server_id = schema_info["server_id"] db_id = schema_info["db_id"] prorettypename = "event_trigger/trigger" server_con = server_utils.connect_server(self, server_id) if not server_con["info"] == "Server connected.": raise Exception("Could not connect to server to add resource " "groups.") if "type" in server_con["data"]: if server_con["data"]["version"] < 90300: prorettypename = "trigger" db_con = database_utils.connect_database(self, utils.SERVER_GROUP, server_id, db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add a function.") schema_id = schema_info["schema_id"] schema_name = schema_info["schema_name"] schema_response = schema_utils.verify_schemas(self.server, db_name, schema_name) if not schema_response: raise Exception("Could not find the schema to add a function.") db_user = self.server["username"] data = { "acl": [ { "grantee": db_user, "grantor": db_user, "privileges": [ { "privilege_type": "X", "privilege": True, "with_grant": True } ] } ], "arguments": [], "funcowner": db_user, "lanname": "plpgsql", "name": "test_abort_any_command", "options": [], "proleakproof": True, "pronamespace": 2200, "prorettypename": prorettypename, "prosecdef": True, "prosrc": "BEGIN RAISE EXCEPTION 'command % is disabled'," " tg_tag; END;", "provolatile": "s", "seclabels": [], "variables": [ { "name": "enable_sort", "value": True } ] } # Get the type from data. We are adding two types # i.e. event_trigger and trigger. trigger_func_types = data['prorettypename'].split('/') for func_type in trigger_func_types: data['prorettypename'] = func_type data["name"] = "test_event_add_%s" % str(uuid.uuid4())[1:8] if schema_id: data['pronamespace'] = schema_id else: schema_id = data['pronamespace'] response = self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(schema_id) + '/', data=json.dumps(data), content_type='html/json' ) self.assertEquals(response.status_code, 200) # Disconnect the database database_utils.disconnect_database(self, server_id, db_id)