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 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"] 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 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 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 setUp(self): self.database_info = parent_node_dict["database"][-1] self.db_name = self.database_info["db_name"] self.did = self.database_info["db_id"] self.sid = parent_node_dict["server"][-1]["server_id"] self.sgid = config_data['server_group'] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, self.sid, self.did) if not db_con['data']["connected"]: raise ExecuteError("Could not connect to database to add a table.") self.schema_id = parent_node_dict['schema'][-1]["schema_id"] self.schema_name = parent_node_dict['schema'][-1]["schema_name"] schema_response = schema_utils.verify_schemas(self.server, self.db_name, self.schema_name) if not schema_response: raise ExecuteError("Could not find the schema to add a table.") self.table_name = "table_for_wizard%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"] 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_name_1 = "test_index_delete_%s" % (str(uuid.uuid4())[1:8]) self.index_ids = [indexes_utils.create_index(self.server, self.db_name, self.schema_name, self.table_name, self.index_name, self.column_name), 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): 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 subscription.") 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 subscription.") 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.subscription_name = "test_subscription_delete_%s" % ( str(uuid.uuid4())[1:8]) self.subscription_name_1 = "test_subscription_delete_%s" % ( str(uuid.uuid4())[1:8]) self.subscription_ids = [ subscription_utils.create_subscription(self.server, self.db_name, self.subscription_name), subscription_utils.create_subscription(self.server, self.db_name, self.subscription_name_1), ]
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 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:6]) 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"] 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 " "a table.") if server_con["data"]["version"] < self.server_min_version: message = "Identity columns are not supported by " \ "PPAS/PG 10.0 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 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_put_%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.col_data_type)
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 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 Policy.") 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 Policy.") self.table_name = "table_for_policy_%s" % (str(uuid.uuid4())[1:8]) self.table_id = tables_utils.create_table(self.server, self.db_name, self.schema_name, self.table_name) if hasattr(self, "owner_policy"): self.role_name = "role_for_policy_%s" % str(uuid.uuid4())[1:8] self.role_id = roles_utils.create_role(self.server, self.role_name)
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 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"] # Check DB 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 " "a table.") self.db_version = server_con["data"]["version"] # Create db connection 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_for_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)
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_constraint_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 Check Constraints self.check_constraint_name = "test_constraint_delete_%s" % \ (str(uuid.uuid4())[1:8]) self.check_constraint_id = \ chk_constraint_utils.create_check_constraint( self.server, self.db_name, self.schema_name, self.table_name, self.check_constraint_name) self.check_constraint_name_1 = "test_constraint_delete1_%s" % (str( uuid.uuid4())[1:8]) self.check_constraint_id_1 = \ chk_constraint_utils.create_check_constraint( self.server, self.db_name, self.schema_name, self.table_name, self.check_constraint_name_1) # Create Exclusion Constraint self.exclustion_constraint_name = "test_exclusion_get_%s" % (str( uuid.uuid4())[1:8]) self.exclustion_constraint_id = \ exclusion_utils.create_exclusion_constraint( self.server, self.db_name, self.schema_name, self.table_name, self.exclustion_constraint_name ) # Create Foreign Key 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) 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.table_name, self.foreign_table_name) # Create Primary Key self.primary_key_name = "test_primary_key_get_%s" % \ (str(uuid.uuid4())[1:8]) self.primary_key_id = \ index_constraint_utils.create_index_constraint( self.server, self.db_name, self.schema_name, self.table_name, self.primary_key_name, "PRIMARY KEY") # Create Unique Key constraint self.unique_constraint_name = "test_unique_constraint_get_%s" % (str( uuid.uuid4())[1:8]) self.unique_constraint_id = \ index_constraint_utils.create_index_constraint( self.server, self.db_name, self.schema_name, self.table_name, self.unique_constraint_name, "UNIQUE")
def setUp(self): super(CheckConstraintDeleteTestCase, 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 delete 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 delete a check " "constraint.") # Create table self.table_name = "table_checkconstraint_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 constraint to delete self.check_constraint_name = "test_checkconstraint_delete_%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) # Cross check constraint creation chk_constraint = check_constraint_utils.verify_check_constraint( self.server, self.db_name, self.check_constraint_name) if not chk_constraint: raise Exception("Could not find the check constraint to delete.") # In case of multiple constraints if self.is_list: # Create constraint to delete self.check_constraint_name_2 = \ "test_checkconstraint_get_list_%s" % (str(uuid.uuid4())[1:8]) self.check_constraint_id_2 = \ check_constraint_utils.create_check_constraint( self.server, self.db_name, self.schema_name, self.table_name, self.check_constraint_name_2) # constraint list to delete self.data['ids'] = [self.check_constraint_id, self.check_constraint_id_2]