diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/__init__.py index 8b5e885..12bdd8e 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/__init__.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/__init__.py @@ -12,6 +12,5 @@ from pgadmin.utils.route import BaseTestGenerator class TriggerFunctionTestGenerator(BaseTestGenerator): - def generate_tests(self): + def runTest(self): return - diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_delete.py index 301540d..3de5b4e 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_delete.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_delete.py @@ -51,6 +51,7 @@ class TriggerFuncDeleteTestCase(BaseTestGenerator): cls.server_ids) # Add schemas schema_utils.add_schemas(cls.tester) + # Add trigger functions trigger_funcs_utils.add_trigger_function( cls.tester, cls.server_connect_response, cls.server_ids) @@ -74,4 +75,3 @@ class TriggerFuncDeleteTestCase(BaseTestGenerator): database_utils.delete_database(cls.tester) server_utils.delete_server(cls.tester) utils.delete_parent_id_file() - diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_get.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_get.py index 083f222..0ba2bca 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_get.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_get.py @@ -68,12 +68,13 @@ class TriggerFuncGetTestCase(BaseTestGenerator): db_con = database_utils.verify_database( self.tester, utils.SERVER_GROUP, server_id, db_id) if db_con['data']["connected"]: - schema_id = schema_ids_dict[int(server_id)] + schema_id = schema_ids_dict[int(server_id)][0] schema_response = schema_utils.verify_schemas( self.tester, server_id, db_id, schema_id) if schema_response.status_code == 200: - trigger_func_ids = trigger_ids_dict[int(server_id)] - for trigger_func_id in trigger_func_ids: + trigger_func_list = trigger_ids_dict[int(server_id)] + for trigger_func in trigger_func_list: + trigger_func_id = trigger_func[0] trigger_response = \ trigger_funcs_utils.verify_trigger_function( self.tester, server_id, db_id, schema_id, diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_put.py index 9a839ef..5025d40 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_put.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/test_trigger_func_put.py @@ -78,8 +78,9 @@ class TriggerFuncPutTestCase(BaseTestGenerator): db_id, schema_id) if schema_response.status_code == 200: - trigger_func_ids = trigger_ids_dict[int(server_id)] - for trigger_func_id in trigger_func_ids: + trigger_func_list = trigger_ids_dict[int(server_id)] + for trigger_func in trigger_func_list: + trigger_func_id = trigger_func[0] trigger_response = \ trigger_funcs_utils.verify_trigger_function( self.tester, server_id, db_id, schema_id, diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/utils.py index 421e2aa..e693c5a 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/utils.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/functions/tests/utils.py @@ -20,6 +20,7 @@ from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ from regression import test_utils as utils TRIGGER_FUNCTIONS_URL = '/browser/trigger_function/obj/' +TRIGGER_FUNCTIONS_DELETE_URL = '/browser/trigger_function/delete/' def get_trigger_func_data(server_connect_data): @@ -68,6 +69,7 @@ def write_trigger_func_id(trigger_func_ids_list, server_id): """ pickle_id_dict = utils.get_pickle_id_dict() + if os.path.isfile(pickle_path): existing_server_id = open(pickle_path, 'rb') tol_server_id = pickle.load(existing_server_id) @@ -100,7 +102,7 @@ def add_trigger_function(tester, server_connect_response, server_ids): if db_con['data']["connected"]: schema_id = schema_ids_dict[int(server_id)][0] schema_utils.verify_schemas(tester, server_id, db_id, - schema_id) + schema_id) data = get_trigger_func_data(server_connect_response) # Get the type from config data. We are adding two types # i.e. event_trigger and trigger. @@ -108,7 +110,7 @@ def add_trigger_function(tester, server_connect_response, server_ids): trigger_func_ids_list = [] for func_type in trigger_func_types: data['prorettypename'] = func_type - data["name"] = str(uuid.uuid4())[1:8] + data["name"] = "event_{}".format(str(uuid.uuid4())[1:8]) if schema_id: data['pronamespace'] = schema_id else: @@ -122,7 +124,9 @@ def add_trigger_function(tester, server_connect_response, server_ids): assert response.status_code == 200 response_data = json.loads(response.data.decode('utf-8')) trigger_func_id = response_data['node']['_id'] - trigger_func_ids_list.append(trigger_func_id) + event_trigger_name = str(response_data['node']['label']) + trigger_func_ids_list.append( + (trigger_func_id, event_trigger_name, func_type)) write_trigger_func_id(trigger_func_ids_list, server_id) @@ -157,13 +161,14 @@ def delete_trigger_function(tester): schema_response = schema_utils.verify_schemas( tester, server_id, db_id, schema_id) if schema_response.status_code == 200: - trigger_func_ids = trigger_ids_dict[int(server_id)] - for trigger_func_id in trigger_func_ids: + trigger_func_list = trigger_ids_dict[int(server_id)] + for trigger_func in trigger_func_list: + trigger_func_id = trigger_func[0] trigger_response = verify_trigger_function( tester, server_id, db_id, schema_id, trigger_func_id) if trigger_response.status_code == 200: del_response = tester.delete( - TRIGGER_FUNCTIONS_URL + str( + TRIGGER_FUNCTIONS_DELETE_URL + str( utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(schema_id) + '/' + str(trigger_func_id), diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/__init__.py new file mode 100644 index 0000000..ace9a3e --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/__init__.py @@ -0,0 +1,16 @@ +########################################################################## +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +########################################################################## + +from pgadmin.utils.route import BaseTestGenerator + + +class SequenceTestGenerator(BaseTestGenerator): + + def runTest(self): + return [] diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_add.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_add.py new file mode 100644 index 0000000..0222621 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_add.py @@ -0,0 +1,72 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from . import utils as sequence_utils + + +class SequenceAddTestCase(BaseTestGenerator): + """ This class will add new sequence(s) under schema node. """ + + scenarios = [ + # Fetching default URL for sequence node. + ('Fetch sequence Node URL', dict(url='/browser/sequence/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the three tasks + 1. Add the test server(s) + 2. Connect to server(s) + 3. Add the database(s) + 4. Add the schema(s) + + :return: None + """ + + # First, add the server + server_utils.add_server(cls.tester) + + # Connect to server + cls.server_connect_response, cls.server_group, cls.server_ids = \ + server_utils.connect_server(cls.tester) + if len(cls.server_connect_response) == 0: + raise Exception("No Server(s) connected to add the database!!!") + + # Add database + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + # Add schemas + schema_utils.add_schemas(cls.tester) + + def runTest(self): + """ This function will add sequence(s) under schema node. """ + + sequence_utils.add_sequences(self.tester) + + @classmethod + def tearDownClass(cls): + """This function deletes the added sequence, schema, database, server + and parent id file + + :return: None + """ + + sequence_utils.delete_sequence(cls.tester) + schema_utils.delete_schema(cls.tester) + database_utils.delete_database(cls.tester) + server_utils.delete_server(cls.tester) + utils.delete_parent_id_file() \ No newline at end of file diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_delete.py new file mode 100644 index 0000000..8e74218 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_delete.py @@ -0,0 +1,75 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from . import utils as sequence_utils + + +class SequenceDeleteTestCase(BaseTestGenerator): + """ This class will delete added sequence under schema node. """ + + scenarios = [ + # Fetching default URL for sequence node. + ('Fetch sequence Node URL', dict(url='/browser/sequence/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the three tasks + 1. Add the test server(s) + 2. Connect to server(s) + 3. Add database(s) + 4. Add schema(s) + 5. Add sequence(s) + + :return: None + """ + + # First, add the server + server_utils.add_server(cls.tester) + + # Connect to server + cls.server_connect_response, cls.server_group, cls.server_ids = \ + server_utils.connect_server(cls.tester) + if len(cls.server_connect_response) == 0: + raise Exception("No Server(s) connected to add the database!!!") + + # Add database(s) + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + # Add schema(s) + schema_utils.add_schemas(cls.tester) + + # Add sequence(s) + sequence_utils.add_sequences(cls.tester) + + def runTest(self): + """ This function will delete added sequence under schema node. """ + + sequence_utils.delete_sequence(self.tester) + + @classmethod + def tearDownClass(cls): + """This function deletes the added sequence, schema, database, server + and parent id file + + :return: None + """ + + schema_utils.delete_schema(cls.tester) + database_utils.delete_database(cls.tester) + server_utils.delete_server(cls.tester) + utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_get.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_get.py new file mode 100644 index 0000000..1941b98 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_get.py @@ -0,0 +1,93 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from . import utils as sequence_utils + + +class SequenceGetTestCase(BaseTestGenerator): + """ This class will fetch added sequence under schema node. """ + + scenarios = [ + # Fetching default URL for sequence node. + ('Fetch sequence Node URL', dict(url='/browser/sequence/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the three tasks + 1. Add the test server(s) + 2. Connect to server(s) + 3. Add database(s) + 4. Add schema(s) + 5. Add sequence(s) + + :return: None + """ + + # First, add the server + server_utils.add_server(cls.tester) + + # Connect to server + cls.server_connect_response, cls.server_group, cls.server_ids = \ + server_utils.connect_server(cls.tester) + if len(cls.server_connect_response) == 0: + raise Exception("No Server(s) connected to add the database!!!") + + # Add database(s) + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + # Add schema(s) + schema_utils.add_schemas(cls.tester) + + # Add sequence(s) + sequence_utils.add_sequences(cls.tester) + + def runTest(self): + """ This function will fetch added sequence under schema node. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + schema_ids_dict = all_id["scid"][0] + sequence_ids_dict = all_id["seid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + schema_info = schema_ids_dict[int(server_id)] + schema_id = schema_info[0] + sequence_id = sequence_ids_dict[server_id] + get_response = sequence_utils.verify_sequence(self.tester, + utils.SERVER_GROUP, + server_id, + db_id, + schema_id, + sequence_id) + self.assertEquals(get_response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """This function delete the added sequence, schema, database, server + and parent id file + + :return: None + """ + + sequence_utils.delete_sequence(cls.tester) + schema_utils.delete_schema(cls.tester) + database_utils.delete_database(cls.tester) + server_utils.delete_server(cls.tester) + utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_put.py new file mode 100644 index 0000000..5e449a3 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/test_sequence_put.py @@ -0,0 +1,112 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from . import utils as sequence_utils +import json +from regression.test_setup import advanced_config_data + + +class SequencePutTestCase(BaseTestGenerator): + """ This class will update added sequence under schema node. """ + + scenarios = [ + # Fetching default URL for sequence node. + ('Fetch sequence Node URL', dict(url='/browser/sequence/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the three tasks + 1. Add the test server(s) + 2. Connect to server(s) + 3. Add database(s) + 4. Add schema(s) + 5. Add sequence(s) + + :return: None + """ + + # First, add the server + server_utils.add_server(cls.tester) + + # Connect to server + cls.server_connect_response, cls.server_group, cls.server_ids = \ + server_utils.connect_server(cls.tester) + if len(cls.server_connect_response) == 0: + raise Exception("No Server(s) connected to add the database!!!") + + # Add database(s) + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + # Add schema(s) + schema_utils.add_schemas(cls.tester) + + # Add sequence(s) + sequence_utils.add_sequences(cls.tester) + + def runTest(self): + """ This function will update added sequence under schema node. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + schema_ids_dict = all_id["scid"][0] + sequence_ids_dict = all_id["seid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + schema_info = schema_ids_dict[int(server_id)] + schema_id = schema_info[0] + sequence_id = sequence_ids_dict[server_id] + get_response = sequence_utils.verify_sequence(self.tester, + utils.SERVER_GROUP, + server_id, + db_id, + schema_id, + sequence_id) + if get_response.status_code == 200: + data = \ + { + "comment": + advanced_config_data['sequnce_update_data'] + ['comment'], + "id": sequence_id + } + + put_response = self.tester.put( + self.url + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + + str(db_id) + '/' + + str(schema_id) + '/' + + str(sequence_id), + data=json.dumps(data), + follow_redirects=True) + self.assertEquals(put_response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """This function deletes the added sequence, schema, database, server + and parent id file + + :return: None + """ + + sequence_utils.delete_sequence(cls.tester) + schema_utils.delete_schema(cls.tester) + database_utils.delete_database(cls.tester) + server_utils.delete_server(cls.tester) + utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/utils.py new file mode 100644 index 0000000..374048d --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/sequences/tests/utils.py @@ -0,0 +1,152 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import json +import os +import pickle +from regression.test_setup import pickle_path, advanced_config_data +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from regression import test_utils as utils +import uuid + +SEQUENCE_URL = '/browser/sequence/obj/' + + +def get_sequence_config_data(schema_name, server_connect_data): + adv_config_data = None + db_user = server_connect_data['data']['user']['name'] + + # Get the config data of appropriate db user + for config_test_data in advanced_config_data['sequence_credentials']: + if db_user == config_test_data['owner']: + adv_config_data = config_test_data + + data = \ + { + "cache": adv_config_data['cache'], + "cycled": adv_config_data['cycled'], + "increment": adv_config_data['increment'], + "maximum": adv_config_data['max_value'], + "minimum": adv_config_data['min_value'], + "name": "sequence_{0}".format(str(uuid.uuid4())[1:4]), + "relacl": adv_config_data['acl'], + "schema": schema_name, + "securities": adv_config_data['security'], + "seqowner": adv_config_data['owner'], + "start": adv_config_data['start_val'] + } + + return data + + +def add_sequences(tester): + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + schema_info_dict = all_id["scid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + db_con = database_utils.verify_database(tester, utils.SERVER_GROUP, + server_id, db_id) + if db_con['data']["connected"]: + server_connect_response = server_utils.verify_server( + tester, utils.SERVER_GROUP, server_id) + + schema_name = schema_info_dict[int(server_id)][1] + data = get_sequence_config_data(schema_name, + server_connect_response) + schema_id = schema_info_dict[int(server_id)][0] + + response = tester.post( + SEQUENCE_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(schema_id) + '/', + data=json.dumps(data), + content_type='html/json') + assert response.status_code == 200 + response_data = json.loads(response.data.decode('utf-8')) + write_sequence_info(response_data, server_id) + + +def write_sequence_info(response_data, server_id): + """ + This function writes the sequence id into parent_id.pkl + + :param response_data: sequence add response data + :type response_data: dict + :param server_id: server id + :type server_id: str + :return: None + """ + + sequence_id = response_data['node']['_id'] + pickle_id_dict = utils.get_pickle_id_dict() + if os.path.isfile(pickle_path): + existing_server_id = open(pickle_path, 'rb') + tol_server_id = pickle.load(existing_server_id) + pickle_id_dict = tol_server_id + if 'fid' in pickle_id_dict: + if pickle_id_dict['seid']: + # Add the sequence_id as value in dict + pickle_id_dict["seid"][0].update({server_id: sequence_id}) + else: + # Create new dict with server_id and sequence_id + pickle_id_dict["seid"].append({server_id: sequence_id}) + sequence_output = open(pickle_path, 'wb') + pickle.dump(pickle_id_dict, sequence_output) + sequence_output.close() + + +def verify_sequence(tester, server_group, server_id, db_id, schema_id, + sequence_id): + """This function verifies the sequence using GET API""" + + get_response = tester.get(SEQUENCE_URL + str(server_group) + '/' + + str(server_id) + '/' + + str(db_id) + '/' + + str(schema_id) + '/' + + str(sequence_id), + content_type='html/json') + + return get_response + + +def delete_sequence(tester): + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + schema_ids_dict = all_id["scid"][0] + sequence_ids_dict = all_id["seid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + schema_info = schema_ids_dict[int(server_id)] + schema_id = schema_info[0] + sequence_id = sequence_ids_dict[server_id] + get_response = verify_sequence(tester, + utils.SERVER_GROUP, + server_id, + db_id, + schema_id, + sequence_id) + if get_response.status_code == 200: + delete_response = tester.delete( + SEQUENCE_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + + str(db_id) + '/' + + str(schema_id) + '/' + + str(sequence_id), + follow_redirects=True) + + assert delete_response.status_code == 200 + del_resp_data = json.loads(delete_response.data.decode('utf-8')) + assert del_resp_data['success'] == 1 diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/__init__.py index 8de0478..c9cf28a 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/__init__.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/__init__.py @@ -12,6 +12,5 @@ from pgadmin.utils.route import BaseTestGenerator class SchemaTestGenerator(BaseTestGenerator): - def generate_tests(self): + def runTest(self): return [] - diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/utils.py index e90500a..4f91484 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/utils.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/utils.py @@ -19,6 +19,7 @@ from pgadmin.browser.server_groups.servers.databases.tests import utils as \ from regression import test_utils as utils SCHEMA_URL = '/browser/schema/obj/' +SCHEMA_DELETE_URL = '/browser/schema/delete/' def get_schema_config_data(server_connect_response): @@ -39,7 +40,7 @@ def get_schema_config_data(server_connect_response): "defseqacl": adv_config_data['seq_acl'], "deftblacl": adv_config_data['tbl_acl'], "deftypeacl": adv_config_data['type_acl'], - "name": "test_{0}".format(str(uuid.uuid4())[1:8]), + "name": "schema_{0}".format(str(uuid.uuid4())[1:8]), "namespaceowner": adv_config_data['owner'], "nspacl": adv_config_data['privilege'], "seclabels": adv_config_data['sec_label'] @@ -138,7 +139,7 @@ def delete_schema(tester): raise Exception("No schema(s) to delete.") del_response = tester.delete( - SCHEMA_URL + str(utils.SERVER_GROUP) + '/' + + SCHEMA_DELETE_URL + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' + str(db_id) + '/' + str(schema_id), diff --git a/web/regression/test_advanced_config.json.in b/web/regression/test_advanced_config.json.in index 538682c..b339c92 100644 --- a/web/regression/test_advanced_config.json.in +++ b/web/regression/test_advanced_config.json.in @@ -299,6 +299,198 @@ "collation_update_data": { "comment": "This is collation update comment" + }, + + "casts_credentials": + [{ + "cast_context": "IMPLICIT", + "encoding": "UTF8", + "name": "money->bigint", + "source_type": "money", + "target_type": "bigint", + "owner": "postgres" + }], + + "cast_update_data": + { + "comment": "This is cast update comment" + }, + + "extension_credentials":[ + { + "name": "postgres_fdw", + "relocate": true, + "schema": "", + "version": "1.0", + "owner": "postgres" + }], + + "extension_update_data": + { + "schema": "schema" + }, + + "fdw_credentials":[ + { + "acl": + [ + { + "grantee":"postgres", + "grantor":"postgres", + "privileges": + [ + { + "privilege_type":"U", + "privilege":true, + "with_grant":true + } + ] + } + ], + "handler": "postgres_fdw_handler", + "options": [], + "owner": "postgres", + "validator": "postgres_fdw_validator", + "name": "fdw" + }], + + "fdw_update_data": + { + "comment": "This is FDW update comment" + }, + + "fsrv_credentials":[ + { + "fsrv_acl": + [ + { + "grantee":"postgres", + "grantor":"postgres", + "privileges": + [ + { + "privilege_type":"U", + "privilege":true, + "with_grant":false + } + ] + } + ], + "fsrv_options": + [ + { + "fsrvoption":"host", + "fsrvvalue":"localhost" + }, + { + "fsrvoption":"port", + "fsrvvalue":"5433" + }, + { + "fsrvoption":"dbname", + "fsrvvalue":"postgres" + } + ], + "owner": "postgres", + "name": "foreign_server1" + }], + + "FSRV_update_data": + { + "comment": "This is foreign server update comment" + }, + + "user_mapping_credentials":[ + { + "name": "postgres", + "option": [], + "owner": "postgres", + "options": + [ + { + "umoption":"user", + "umvalue":"postgres" + }, + { + "umoption":"password", + "umvalue":"edb" + } + ] + }], + + "user_mapping_update_data": + { + "options": + { + "changed": + [ + {"umoption":"password", + "umvalue":"edb1" + } + ] + } + }, + + "event_trigger_credentials": + [{ + "enable": "O", + "event_func": "test_schema.test_abort_any_command", + "event_name": "DDL_COMMAND_END", + "owner": "postgres", + "name": "test_event_trg", + "provider": [] + }], + + "event_trigger_update_data": + { + "comment": "This is event trigger update comment" + }, + + "sequence_credentials": + [{ + "cache": "1", + "cycled": true, + "increment": "1", + "max_value": "100000", + "min_value": "1", + "name": "test_empno", + "acl": + [ + { + "grantee":"postgres", + "grantor":"postgres", + "privileges": + [ + { + "privilege_type":"r", + "privilege":true, + "with_grant":false + }, + { + "privilege_type":"w", + "privilege":true, + "with_grant":false + }, + { + "privilege_type":"U", + "privilege":true, + "with_grant":false + } + ] + } + ], + "schema_name": "test_schema", + "security": [], + "owner": "postgres", + "start_val": "100" + }], + + "sequnce_update_data": + { + "comment": "This is sequence update comment" } -} \ No newline at end of file + + } + + diff --git a/web/regression/test_utils.py b/web/regression/test_utils.py index ec33680..e078eaa 100644 --- a/web/regression/test_utils.py +++ b/web/regression/test_utils.py @@ -9,7 +9,6 @@ import os import pickle - from test_setup import config_data, pickle_path @@ -26,7 +25,14 @@ def get_pickle_id_dict(): "tsid": [], # tablespace "scid": [], # schema "tfnid": [], # trigger functions - "coid": [] # collation + "coid": [], # collation + "cid": [], # casts + "etid": [], # event_trigger + "eid": [], # extension + "fid": [], # FDW + "fsid": [], # FRS + "umid": [], # user_mapping + "seid": [] # sequence } return pickle_id_dict