diff --git a/web/pgadmin/browser/server_groups/servers/databases/casts/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/casts/tests/__init__.py new file mode 100644 index 0000000..bfb0263 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/casts/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 CastTestGenerator(BaseTestGenerator): + + def runTest(self): + return [] diff --git a/web/pgadmin/browser/server_groups/servers/databases/casts/tests/test_cast_add.py b/web/pgadmin/browser/server_groups/servers/databases/casts/tests/test_cast_add.py new file mode 100644 index 0000000..0dff330 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/casts/tests/test_cast_add.py @@ -0,0 +1,65 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from . import utils as cast_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils + + +class CastsAddTestCase(BaseTestGenerator): + scenarios = [ + # Fetching default URL for cast node. + ('Check Cast Node', dict(url='/browser/cast/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + + :return: None + """ + + # 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) + + def runTest(self): + """ This function will add cast under database node. """ + + cast_utils.add_cast(self.tester) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added cast, database, server and the + 'parent_id.pkl' file which is created in setUpClass. + + :return: None + """ + + cast_utils.delete_cast(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/casts/tests/test_cast_delete.py b/web/pgadmin/browser/server_groups/servers/databases/casts/tests/test_cast_delete.py new file mode 100644 index 0000000..f3a92c9 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/casts/tests/test_cast_delete.py @@ -0,0 +1,102 @@ +# # ################################################################# +# # +# # 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 +from regression import test_utils as utils +from regression.test_utils import get_ids +from . import utils as cast_utils +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.test_setup import advanced_config_data +import json + + +class CastsDeleteTestCase(BaseTestGenerator): + """ This class will fetch the cast node added under database node. """ + + scenarios = [ + # Fetching default URL for cast node. + ('Check Cast Node', dict(url='/browser/cast/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add cast(s) to databases + + :return: None + """ + + # 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 cast(s) to database(s) + cast_utils.add_cast(cls.tester) + + def runTest(self): + """ This function will delete added cast(s).""" + + all_id = get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + cast_ids_dict = all_id["cid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + db_con = database_utils.verify_database(self.tester, + utils.SERVER_GROUP, + server_id, + db_id) + if len(db_con) == 0: + raise Exception("No database(s) to delete for server id %s" + % server_id) + cast_id = cast_ids_dict[server_id] + cast_get_data = cast_utils.verify_cast(self.tester, + utils.SERVER_GROUP, + server_id, + db_id, cast_id) + + if cast_get_data.status_code == 200: + + delete_response = self.tester.delete( + self.url + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(cast_id), + follow_redirects=True) + response_data = json.loads(delete_response.data.decode('utf-8')) + self.assertTrue(response_data['success'], 1) + + @classmethod + def tearDownClass(cls): + """ + This function delete the added cast, database, server and the + 'parent_id.pkl' file which is created in setUpClass. + + :return: None + """ + + 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/casts/tests/test_cast_get.py b/web/pgadmin/browser/server_groups/servers/databases/casts/tests/test_cast_get.py new file mode 100644 index 0000000..20702e1 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/casts/tests/test_cast_get.py @@ -0,0 +1,87 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from regression.test_utils import get_ids +from . import utils as cast_utils +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 + + +class CastsGetTestCase(BaseTestGenerator): + """ This class will fetch the cast node added under database node. """ + + scenarios = [ + # Fetching default URL for cast node. + ('Check Cast Node', dict(url='/browser/cast/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function used to add the sever, database, and cast + + :return: None + """ + + # 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) + + cast_utils.add_cast(cls.tester) + + def runTest(self): + """ This function will get added cast.""" + + all_id = get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + cast_ids_dict = all_id["cid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + db_con = database_utils.verify_database(self.tester, + utils.SERVER_GROUP, + server_id, + db_id) + if len(db_con) == 0: + raise Exception("No database(s) to delete for server id %s" + % server_id) + cast_id = cast_ids_dict[server_id] + cast_get_data = cast_utils.verify_cast(self.tester, + utils.SERVER_GROUP, + server_id, + db_id, cast_id) + self.assertEquals(cast_get_data.status_code, 200) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added cast, database, server and the + 'parent_id.pkl' file which is created in setup() function. + + :return: None + """ + + cast_utils.delete_cast(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/casts/tests/test_cast_put.py b/web/pgadmin/browser/server_groups/servers/databases/casts/tests/test_cast_put.py new file mode 100644 index 0000000..ea67c77 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/casts/tests/test_cast_put.py @@ -0,0 +1,107 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from regression.test_utils import get_ids +from . import utils as cast_utils +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.test_setup import advanced_config_data +import json + + +class CastsPutTestCase(BaseTestGenerator): + """ This class will fetch the cast node added under database node. """ + + scenarios = [ + # Fetching default URL for cast node. + ('Check Cast Node', dict(url='/browser/cast/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add cast(s) to databases + + :return: None + """ + + # 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) + + cast_utils.add_cast(cls.tester) + + def runTest(self): + """ This function will update added cast.""" + + all_id = get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + cast_ids_dict = all_id["cid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + db_con = database_utils.verify_database(self.tester, + utils.SERVER_GROUP, + server_id, + db_id) + if len(db_con) == 0: + raise Exception("No database(s) to delete for server id %s" + % server_id) + cast_id = cast_ids_dict[server_id] + cast_get_data = cast_utils.verify_cast(self.tester, + utils.SERVER_GROUP, + server_id, + db_id, cast_id) + + if cast_get_data.status_code == 200: + + data = { + "description": advanced_config_data["cast_update_data"] + ["comment"], + "id": cast_id + } + + put_response = self.tester.put( + self.url + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str( + db_id) + + '/' + str(cast_id), + data=json.dumps(data), + follow_redirects=True) + self.assertEquals(put_response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added cast, database, server and the + 'parent_id.pkl' file which is created in setUpClass. + + :return: None + """ + + cast_utils.delete_cast(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/casts/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/casts/tests/utils.py new file mode 100644 index 0000000..0e89513 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/casts/tests/utils.py @@ -0,0 +1,145 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import os +import pickle +import json +from regression.test_setup import advanced_config_data, pickle_path +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils + +CAST_URL = '/browser/cast/obj/' + + +def get_cast_config_data(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['casts_credentials']: + if db_user == config_test_data['owner']: + adv_config_data = config_test_data + + data = { + "castcontext": adv_config_data + ['cast_context'], + "encoding": adv_config_data + ['encoding'], + "name": adv_config_data + ['name'], + "srctyp": adv_config_data + ['source_type'], + "trgtyp": adv_config_data + ['target_type'] + } + return data + + +def add_cast(tester): + """ + This function add the cast in the existing database + + :param tester: test object + :type tester: flask test object + :return:None + """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + server_group = utils.config_data['server_group'] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + db_con = database_utils.verify_database(tester, server_group, + server_id, db_id) + if db_con['data']['connected']: + server_connect_response = server_utils.verify_server( + tester, server_group, server_id) + + data = get_cast_config_data(server_connect_response) + + response = tester.post(CAST_URL + str(server_group) + '/' + + str(server_id) + '/' + str( + db_id) + '/', + data=json.dumps(data), + content_type='html/json') + + assert response.status_code == 200 + response_data = json.loads(response.data.decode('utf-8')) + write_cast_info(response_data, server_id) + + +def write_cast_info(response_data, server_id): + """ + This function writes the server's details to file parent_id.pkl + + :param response_data: server's data + :type response_data: list of dictionary + :param pickle_id_dict: contains ids of server,database,tables etc. + :type pickle_id_dict: dict + :return: None + """ + + cast_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 'cid' in pickle_id_dict: + if pickle_id_dict['cid']: + # Add the cast_id as value in dict + pickle_id_dict["cid"][0].update({server_id: cast_id}) + else: + # Create new dict with server_id and cast_id + pickle_id_dict["cid"].append({server_id: cast_id}) + cast_output = open(pickle_path, 'wb') + pickle.dump(pickle_id_dict, cast_output) + cast_output.close() + + +def verify_cast(tester, server_group, server_id, db_id, cast_id): + + cast_response = tester.get(CAST_URL + str(server_group) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(cast_id), + content_type='html/json') + return cast_response + + +def delete_cast(tester): + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + cast_ids_dict = all_id["cid"][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 len(db_con) == 0: + raise Exception("No database(s) to delete for server id %s" + % server_id) + cast_id = cast_ids_dict[server_id] + cast_get_data = verify_cast(tester, utils.SERVER_GROUP, + server_id, + db_id, cast_id) + + if cast_get_data.status_code == 200: + delete_response = tester.delete( + CAST_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(cast_id), + follow_redirects=True) + return delete_response diff --git a/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/__init__.py new file mode 100644 index 0000000..80a2bdd --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/event_triggers/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 EventTriggerGeneratorTestCase(BaseTestGenerator): + + def runTest(self): + return [] diff --git a/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/test_event_trigger_add.py b/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/test_event_trigger_add.py new file mode 100644 index 0000000..dbd9353 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/test_event_trigger_add.py @@ -0,0 +1,79 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.schemas.functions.tests \ + import utils as func_utils +from . import utils as event_trigger_utils + + +class EventTriggerAddTestCase(BaseTestGenerator): + """ This class will add new event trigger under schema node. """ + + scenarios = [ + # Fetching default URL for event trigger node. + ('Fetch Event Trigger Node URL', + dict(url='/browser/event_trigger/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add trigger function(s) to schema(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + schema_utils.add_schemas(cls.tester) + + func_utils.add_trigger_function(cls.tester, cls.server_connect_response, + cls.server_ids) + + def runTest(self): + """ This function will add event trigger under database node. """ + event_trigger_utils.add_event_trigger(self.tester) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + + :return: None + """ + + event_trigger_utils.delete_event_trigger(cls.tester) + func_utils.delete_trigger_function(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/event_triggers/tests/test_event_trigger_delete.py b/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/test_event_trigger_delete.py new file mode 100644 index 0000000..85c21e3 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/test_event_trigger_delete.py @@ -0,0 +1,88 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.schemas.functions.tests \ + import utils as func_utils +from . import utils as event_trigger_utils +import json + + +class EventTriggerDeleteTestCase(BaseTestGenerator): + """ This class will fetch added event trigger under database node. """ + + scenarios = [ + # Fetching default URL for event trigger node. + ('Fetch Event Trigger Node URL', + dict(url='/browser/event_trigger/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add trigger function(s) to schema(s) + 5. Add event trigger(s) to database(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + schema_utils.add_schemas(cls.tester) + + func_utils.add_trigger_function(cls.tester, cls.server_connect_response, + cls.server_ids) + + event_trigger_utils.add_event_trigger(cls.tester) + + def runTest(self): + """ This function will delete event trigger under database node. """ + + del_response = event_trigger_utils.delete_event_trigger(self.tester) + + del_respdata = json.loads(del_response.data.decode("utf-8")) + + self.assertTrue(del_respdata['success'], 1) + + @classmethod + def tearDownClass(cls): + """ + This function delete the added schema, database, server and parent + id file + + :return: None + """ + + func_utils.delete_trigger_function(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/event_triggers/tests/test_event_trigger_get.py b/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/test_event_trigger_get.py new file mode 100644 index 0000000..f1478e6 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/test_event_trigger_get.py @@ -0,0 +1,97 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import\ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.schemas.functions.tests \ + import utils as func_utils +from . import utils as event_trigger_utils + + +class EventTriggerGetTestCase(BaseTestGenerator): + """ This class will fetch added event trigger under schema node. """ + + scenarios = [ + # Fetching default URL for event trigger node. + ('Fetch Event Trigger Node URL', + dict(url='/browser/event_trigger/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add trigger function(s) to schema(s) + 5. Add event trigger(s) to database(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + schema_utils.add_schemas(cls.tester) + + func_utils.add_trigger_function(cls.tester, cls.server_connect_response, + cls.server_ids) + + event_trigger_utils.add_event_trigger(cls.tester) + + def runTest(self): + """ This function will fetch event trigger under database node. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + event_trigger_ids_dict = all_id["etid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + event_trigger_id = event_trigger_ids_dict[server_id] + + response = event_trigger_utils.verify_event_trigger( + self.tester, utils.SERVER_GROUP, server_id, db_id, + event_trigger_id) + + self.assertEquals(response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + + :return: None + """ + + event_trigger_utils.delete_event_trigger(cls.tester) + func_utils.delete_trigger_function(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/event_triggers/tests/test_event_trigger_put.py b/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/test_event_trigger_put.py new file mode 100644 index 0000000..31d3e55 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/test_event_trigger_put.py @@ -0,0 +1,114 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.schemas.functions.tests \ + import utils as func_utils +from . import utils as event_trigger_utils +import json +from regression.test_setup import advanced_config_data + + +class EventTriggerPutTestCase(BaseTestGenerator): + """ This class will fetch added event trigger under database node. """ + + scenarios = [ + # Fetching default URL for event trigger node. + ('Fetch Event Trigger Node URL', + dict(url='/browser/event_trigger/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add trigger function(s) to schema(s) + 5. Add event trigger(s) to database(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + schema_utils.add_schemas(cls.tester) + + func_utils.add_trigger_function(cls.tester, cls.server_connect_response, + cls.server_ids) + + event_trigger_utils.add_event_trigger(cls.tester) + + def runTest(self): + """ This function will update event trigger under database node. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + event_trigger_ids_dict = all_id["etid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + event_trigger_id = event_trigger_ids_dict[server_id] + + response = event_trigger_utils.verify_event_trigger( + self.tester, utils.SERVER_GROUP, server_id, db_id, + event_trigger_id) + + if response.status_code == 200: + data = \ + { + "comment": + advanced_config_data['event_trigger_update_data'] + ['comment'], + "id": event_trigger_id + } + + put_response = self.tester.put( + self.url + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(event_trigger_id), + data=json.dumps(data), + follow_redirects=True) + + self.assertEquals(put_response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + + :return: None + """ + + event_trigger_utils.delete_event_trigger(cls.tester) + func_utils.delete_trigger_function(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/event_triggers/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/utils.py new file mode 100644 index 0000000..1fcecb7 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/event_triggers/tests/utils.py @@ -0,0 +1,148 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import os +import pickle +import json +import uuid +from regression.test_setup import advanced_config_data, pickle_path +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.schemas.functions.tests \ + import utils as func_utils + +EVENT_TRIGGER_URL = '/browser/event_trigger/obj/' + + +def get_event_trigger_config_data(schema_name, server_connect_data, + trigger_func_name): + 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['event_trigger_credentials']: + if db_user == config_test_data['owner']: + adv_config_data = config_test_data + + data = { + "enabled": adv_config_data['enable'], + "eventfunname": "{0}.{1}".format(schema_name, trigger_func_name), + "eventname": adv_config_data['event_name'], + "eventowner": adv_config_data['owner'], + "name": "event_trigger_{}".format(str(uuid.uuid4())[1:4]), + "providers": adv_config_data['provider'] + } + return data + + +def add_event_trigger(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] + trigger_func_info_dict = all_id["tfnid"][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_info = schema_info_dict[int(server_id)] + trigger_func_list = trigger_func_info_dict[int(server_id)] + trigger_func_info = \ + filter(lambda x: x[2] == "event_trigger", trigger_func_list)[0] + trigger_func_name = trigger_func_info[1].replace("()", "") + trigger_func_id = trigger_func_info[0] + + trigger_func_response = \ + func_utils.verify_trigger_function(tester, server_id, + db_id, schema_info[0], + trigger_func_id) + if trigger_func_response.status_code == 200: + data = get_event_trigger_config_data( + schema_info[1], + server_connect_response, trigger_func_name) + + response = tester.post( + EVENT_TRIGGER_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + + '/', data=json.dumps(data), + content_type='html/json') + assert response.status_code == 200 + response_data = json.loads(response.data.decode('utf-8')) + write_event_trigger_info(response_data, server_id) + + +def write_event_trigger_info(response_data, server_id): + """ + This function writes the schema id into parent_id.pkl + + :param response_data: extension add response data + :type response_data: dict + :param server_id: server id + :type server_id: str + :return: None + """ + + event_trigger_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 'etid' in pickle_id_dict: + if pickle_id_dict['etid']: + # Add the event_trigger_id as value in dict + pickle_id_dict["etid"][0].update({server_id: event_trigger_id}) + else: + # Create new dict with server_id and event_trigger_id + pickle_id_dict["etid"].append({server_id: event_trigger_id}) + event_trigger_output = open(pickle_path, 'wb') + pickle.dump(pickle_id_dict, event_trigger_output) + event_trigger_output.close() + + +def verify_event_trigger(tester, server_group, server_id, db_id, + event_trigger_id): + response = tester.get(EVENT_TRIGGER_URL + str(server_group) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(event_trigger_id), + content_type='html/json') + return response + + +def delete_event_trigger(tester): + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + event_trigger_ids_dict = all_id["etid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + event_trigger_id = event_trigger_ids_dict[server_id] + + response = verify_event_trigger(tester, + utils.SERVER_GROUP, + server_id, + db_id, + event_trigger_id) + if response.status_code == 200: + del_response = tester.delete( + EVENT_TRIGGER_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + + str(db_id) + '/' + + str(event_trigger_id), + follow_redirects=True) + + return del_response diff --git a/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/__init__.py new file mode 100644 index 0000000..025b57e --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/extensions/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 ExtensionGeneratorTestCase(BaseTestGenerator): + + def runTest(self): + return [] \ No newline at end of file diff --git a/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_add.py b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_add.py new file mode 100644 index 0000000..7e3486e --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_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 pgadmin.utils.route import BaseTestGenerator +from regression import test_utils as utils +from . import utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import\ + utils as schema_utils + + + +class ExtensionsAddTestCase(BaseTestGenerator): + + scenarios = [ + # Fetching default URL for extension node. + ('Check Extension Node', dict(url='/browser/extension/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + schema_utils.add_schemas(cls.tester) + + def runTest(self): + """ This function will add extension under 1st server of tree node. """ + + extension_utils.add_extensions(self.tester) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + + :return: None + """ + + extension_utils.delete_extension(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/extensions/tests/test_extension_delete.py b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_delete.py new file mode 100644 index 0000000..e9164cd --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_delete.py @@ -0,0 +1,74 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import json +from pgadmin.utils.route import BaseTestGenerator +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from . import utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils + + +class ExtensionsDeleteTestCase(BaseTestGenerator): + + scenarios = [ + # Fetching default URL for extension node. + ('Check Extension Node', dict(url='/browser/extension/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add extension(s) to schema(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + # Add schema(s) to database(s) + schema_utils.add_schemas(cls.tester) + + # Add extension(s) to schema(s) + extension_utils.add_extensions(cls.tester) + + def runTest(self): + """ This function will add extension under 1st server of tree node. """ + + delete_respdata = extension_utils.delete_extension(self.tester) + self.assertTrue(delete_respdata['success'], 1) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + """ + + 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/extensions/tests/test_extension_get.py b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_get.py new file mode 100644 index 0000000..764bc6c --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_get.py @@ -0,0 +1,87 @@ +################################################################# + +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence + +################################################################## + +import json +from pgadmin.utils.route import BaseTestGenerator +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from . import utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils + + +class ExtensionsGetTestCase(BaseTestGenerator): + + scenarios = [ + # Fetching default URL for extension node. + ('Check Extension Node', dict(url='/browser/extension/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add extension(s) to schema(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + schema_utils.add_schemas(cls.tester) + + extension_utils.add_extensions(cls.tester) + + def runTest(self): + """ This function will add extension under 1st server of tree node. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + extension_ids_dict = all_id["eid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + extension_id = extension_ids_dict[server_id] + + response = extension_utils.verify_extensions(self.tester, + utils.SERVER_GROUP, + server_id, db_id, + extension_id) + + self.assertEquals(response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + """ + + extension_utils.delete_extension(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/extensions/tests/test_extension_put.py b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_put.py new file mode 100644 index 0000000..7a11ed5 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/test_extension_put.py @@ -0,0 +1,104 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + + +import json +from pgadmin.utils.route import BaseTestGenerator +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from . import utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils + + +class ExtensionsPutTestCase(BaseTestGenerator): + + scenarios = [ + # Fetching default URL for extension node. + ('Check Extension Node', dict(url='/browser/extension/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add extension(s) to schema(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + schema_utils.add_schemas(cls.tester) + + extension_utils.add_extensions(cls.tester) + + def runTest(self): + """ This function will add extension under 1st server of tree node. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + extension_ids_dict = all_id["eid"][0] + schema_info_dict = all_id["scid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + extension_id = extension_ids_dict[server_id] + + response = extension_utils.verify_extensions(self.tester, + utils.SERVER_GROUP, + server_id, db_id, + extension_id) + + if response.status_code == 200: + schema_name = schema_info_dict[int(server_id)][1] + + data = \ + { + "id": extension_id, + "schema": schema_name + } + + put_response = self.tester.put( + self.url + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(extension_id), + data=json.dumps(data), + follow_redirects=True) + + self.assertEquals(put_response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + """ + extension_utils.delete_extension(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/extensions/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/utils.py new file mode 100644 index 0000000..e5b108d --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/extensions/tests/utils.py @@ -0,0 +1,134 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + + +import os +import pickle +import json +from regression.test_setup import advanced_config_data, pickle_path +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils + + +EXTENSION_URL = '/browser/extension/obj/' + + +def get_extension_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['extension_credentials']: + if db_user == config_test_data['owner']: + adv_config_data = config_test_data + + data = { + "name": adv_config_data['name'], + "relocatable": adv_config_data['relocate'], + "schema": schema_name, + "version": adv_config_data['version'] + } + return data + + +def write_extension_info(response_data, server_id): + """ + This function writes the schema id into parent_id.pkl + + :param response_data: extension add response data + :type response_data: dict + :param server_id: server id + :type server_id: str + :return: None + """ + + extension_id = response_data['node']['_id'] + # schema_name = str(response_data['node']['label']) + 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 'eid' in pickle_id_dict: + if pickle_id_dict['eid']: + # Add the extension_id as value in dict + pickle_id_dict["eid"][0].update({server_id: extension_id}) + else: + # Create new dict with server_id and extension_id + pickle_id_dict["eid"].append({server_id: extension_id}) + extension_output = open(pickle_path, 'wb') + pickle.dump(pickle_id_dict, extension_output) + extension_output.close() + + +def add_extensions(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_extension_config_data(schema_name, + server_connect_response) + + response = tester.post( + EXTENSION_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str( + db_id) + '/', + data=json.dumps(data), + content_type='html/json') + assert response.status_code == 200 + response_data = json.loads(response.data.decode('utf-8')) + write_extension_info(response_data, server_id) + + +def verify_extensions(tester, server_group, server_id, db_id, extension_id): + + response = tester.get(EXTENSION_URL + str(server_group) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(extension_id), + content_type='html/json') + return response + + +def delete_extension(tester): + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + extension_ids_dict = all_id["eid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + extension_id = extension_ids_dict[server_id] + + response = verify_extensions(tester, + utils.SERVER_GROUP, + server_id, db_id, + extension_id) + if response.status_code == 200: + delete_response = tester.delete( + EXTENSION_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + + str(db_id) + '/' + + str(extension_id), + follow_redirects=True) + delete_respdata = json.loads(delete_response.data.decode()) + return delete_respdata diff --git a/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/__init__.py new file mode 100644 index 0000000..8fd1422 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/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 ForeignServersGeneratorTestCase(BaseTestGenerator): + + def runTest(self): + return [] \ No newline at end of file diff --git a/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/test_foreign_servers_add.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/test_foreign_servers_add.py new file mode 100644 index 0000000..ee04f80 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/test_foreign_servers_add.py @@ -0,0 +1,88 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.extensions.tests import\ + utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.tests \ + import utils as fdw_utils +from . import utils as fsrv_utils + + +class ForeignServerAddTestCase(BaseTestGenerator): + """ + This class will add foreign server under database node. + """ + + scenarios = [ + # Fetching default URL for foreign server node. + ('Check FSRV Node', dict(url='/browser/foreign_server/obj/')) + ] + + @classmethod + def setUpClass(cls): + """" + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add extension(s) to schema(s) + 5. Add foreign data wrapper(s) to extension(s) + + :return: None" + """ + + # Add the server(s) + server_utils.add_server(cls.tester) + + # Connect to server(s) + 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) to connected server(s) + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + # Add schema(s) under connected database(s) + schema_utils.add_schemas(cls.tester) + + # Add extension(s) to schema(s) + extension_utils.add_extensions(cls.tester) + + # Add foreign data wrapper(s) to extension(s) + fdw_utils.add_fdw(cls.tester) + + def runTest(self): + """ This function will add foreign server under database node. """ + + fsrv_utils.add_fsrv(self.tester) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + + :return: None + """ + fsrv_utils.delete_fsrv(cls.tester) + fdw_utils.delete_fdw(cls.tester) + extension_utils.delete_extension(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/foreign_data_wrappers/foreign_servers/tests/test_foreign_servers_delete.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/test_foreign_servers_delete.py new file mode 100644 index 0000000..1420cbb --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/test_foreign_servers_delete.py @@ -0,0 +1,94 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.extensions.tests import\ + utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.tests\ + import utils as fdw_utils +from . import utils as fsrv_utils + + +class ForeignServerDeleteTestCase(BaseTestGenerator): + """ + This class will add foreign server under FDW node. + """ + + scenarios = [ + # Fetching default URL for foreign server node. + ('Check FSRV Node', dict(url='/browser/foreign_server/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add extension(s) to schema(s) + 5. Add foreign data wrapper(s) to extension(s) + 6. Add foreign server(s) to foreign data wrapper(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + # Add schema(s) under connected database(s) + schema_utils.add_schemas(cls.tester) + + # Add extension(s) to schema(s) + extension_utils.add_extensions(cls.tester) + + # Add foreign data wrapper(s) to extension(s) + fdw_utils.add_fdw(cls.tester) + + # Add foreign server(s) to foreign data wrapper + fsrv_utils.add_fsrv(cls.tester) + +# + def runTest(self): + """ This function will delete foreign server under FDW node. """ + + delete_respdata = fsrv_utils.delete_fsrv(self.tester) + self.assertTrue(delete_respdata['success'], 1) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + + :return: None + """ + + fdw_utils.delete_fdw(cls.tester) + extension_utils.delete_extension(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/foreign_data_wrappers/foreign_servers/tests/test_foreign_servers_get.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/test_foreign_servers_get.py new file mode 100644 index 0000000..4d0b5f5 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/test_foreign_servers_get.py @@ -0,0 +1,110 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.extensions.tests import\ + utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.tests\ + import utils as fdw_utils +from . import utils as fsrv_utils + +class ForeignServerGetTestCase(BaseTestGenerator): + """ + This class will add foreign server under FDW node. + """ + + scenarios = [ + # Fetching default URL for foreign server node. + ('Check FSRV Node', dict(url='/browser/foreign_server/obj/')) + ] + + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add extension(s) to schema(s) + 5. Add foreign data wrapper(s) to extension(s) + 6. Add foreign server(s) to foreign data wrapper(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + # Add schema(s) under connected database(s) + schema_utils.add_schemas(cls.tester) + + # Add extension(s) to schema(s) + extension_utils.add_extensions(cls.tester) + + # Add foreign data wrapper(s) to extension(s) + fdw_utils.add_fdw(cls.tester) + + # Add foreign server(s) to foreign data wrapper + fsrv_utils.add_fsrv(cls.tester) + +# + def runTest(self): + """ This function will fetch foreign server under FDW node. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + fdw_ids_dict = all_id["fid"][0] + fsrv_ids_dict = all_id["fsid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + fdw_id = fdw_ids_dict[server_id] + fsrv_id = fsrv_ids_dict[server_id] + + response = fsrv_utils.verify_fsrv(self.tester, utils.SERVER_GROUP, + server_id, db_id, + fdw_id, fsrv_id) + + self.assertEquals(response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + + :return: None + """ + + fsrv_utils.delete_fsrv(cls.tester) + fdw_utils.delete_fdw(cls.tester) + extension_utils.delete_extension(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/foreign_data_wrappers/foreign_servers/tests/test_foreign_servers_put.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/test_foreign_servers_put.py new file mode 100644 index 0000000..4e5809a --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/test_foreign_servers_put.py @@ -0,0 +1,128 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.extensions.tests import\ + utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.tests\ + import utils as fdw_utils +from . import utils as fsrv_utils +from regression.test_setup import advanced_config_data +import json + +class ForeignServerPutTestCase(BaseTestGenerator): + """ + This class will add foreign server under FDW node. + """ + + scenarios = [ + # Fetching default URL for foreign server node. + ('Check FSRV Node', dict(url='/browser/foreign_server/obj/')) + ] + + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add extension(s) to schema(s) + 5. Add foreign data wrapper(s) to extension(s) + 6. Add foreign server(s) to foreign data wrapper(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + # Add schema(s) under connected database(s) + schema_utils.add_schemas(cls.tester) + + # Add extension(s) to schema(s) + extension_utils.add_extensions(cls.tester) + + # Add foreign data wrapper(s) to extension(s) + fdw_utils.add_fdw(cls.tester) + + # Add foreign server(s) to foreign data wrapper + fsrv_utils.add_fsrv(cls.tester) + +# + def runTest(self): + """ This function will update foreign server under FDW node. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + fdw_ids_dict = all_id["fid"][0] + fsrv_ids_dict = all_id["fsid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + fdw_id = fdw_ids_dict[server_id] + fsrv_id = fsrv_ids_dict[server_id] + + response = fsrv_utils.verify_fsrv(self.tester, utils.SERVER_GROUP, + server_id, db_id, + fdw_id, fsrv_id) + + if response.status_code == 200: + data = \ + { + "description": advanced_config_data['FSRV_update_data'] + ['comment'], + "id": fsrv_id + } + + put_response = self.tester.put( + self.url + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(fdw_id) + '/' + + str(fsrv_id), data=json.dumps(data), + follow_redirects=True) + + self.assertEquals(put_response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added foreign server(s) , + foreign data wrapper(s), extension(s), schema(s), database(s), server(s) + and parent id file + + :return: None + """ + + fsrv_utils.delete_fsrv(cls.tester) + fdw_utils.delete_fdw(cls.tester) + extension_utils.delete_extension(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/foreign_data_wrappers/foreign_servers/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/utils.py new file mode 100644 index 0000000..e271643 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/tests/utils.py @@ -0,0 +1,149 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import os +import pickle +import json +from regression.test_setup import advanced_config_data, pickle_path +from regression import test_utils as utils +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 +import uuid +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.tests \ + import utils as fdw_utils + + +FSRV_URL = '/browser/foreign_server/obj/' + + +def get_fsrv_config_data(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['fsrv_credentials']: + if db_user == config_test_data['owner']: + adv_config_data = config_test_data + + data = { + "fsrvacl": adv_config_data['fsrv_acl'], + "fsrvoptions": adv_config_data['fsrv_options'], + "fsrvowner": adv_config_data['owner'], + "name": "fsrv_{}".format(str(uuid.uuid4())[1:4]) + } + + return data + + +def add_fsrv(tester): + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + fdw_ids_dict = all_id["fid"][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) + + fdw_id = fdw_ids_dict[server_id] + + response = fdw_utils.verify_fdws(tester, + utils.SERVER_GROUP, + server_id, db_id, + fdw_id) + + if response.status_code == 200: + data = get_fsrv_config_data(server_connect_response) + + response = tester.post( + FSRV_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str( + db_id) + + '/' + str(fdw_id) + '/', + data=json.dumps(data), + content_type='html/json') + + assert response.status_code == 200 + + response_data = json.loads(response.data.decode()) + write_fsrv_info(response_data, server_id) + + +def write_fsrv_info(response_data, server_id): + """ + This function writes the schema id into parent_id.pkl + + :param response_data: foreign server add response data + :type response_data: dict + :param server_id: server id + :type server_id: str + :return: None + """ + + fsrv_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 'fsid' in pickle_id_dict: + if pickle_id_dict['fsid']: + # Add the FSRV_id as value in dict + pickle_id_dict["fsid"][0].update({server_id: fsrv_id}) + else: + # Create new dict with server_id and fsrv_id + pickle_id_dict["fsid"].append({server_id: fsrv_id}) + fsrv_output = open(pickle_path, 'wb') + pickle.dump(pickle_id_dict, fsrv_output) + fsrv_output.close() + + +def verify_fsrv(tester, server_group, server_id, db_id, fdw_id, fsrv_id): + response = tester.get(FSRV_URL + str(server_group) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(fdw_id) + '/' + str(fsrv_id), + content_type='html/json') + return response + + +def delete_fsrv(tester): + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + fdw_ids_dict = all_id["fid"][0] + fsrv_ids_dict = all_id["fsid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + fdw_id = fdw_ids_dict[server_id] + fsrv_id = fsrv_ids_dict[server_id] + + response = verify_fsrv(tester, utils.SERVER_GROUP, + server_id, db_id, + fdw_id, fsrv_id) + + if response.status_code == 200: + delete_response = tester.delete( + FSRV_URL + str(utils.SERVER_GROUP) + + '/' + str(server_id) + '/' + + str(db_id) + '/' + + str(fdw_id) + '/' + + str(fsrv_id), + follow_redirects=True) + + delete_respdata = json.loads(delete_response.data.decode()) + return delete_respdata diff --git a/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/__init__.py new file mode 100644 index 0000000..0b87db2 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/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 UserMappingGeneratorTestCase(BaseTestGenerator): + + def runTest(self): + return [] \ No newline at end of file diff --git a/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/test_user_mapping_add.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/test_user_mapping_add.py new file mode 100644 index 0000000..e4551e7 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/test_user_mapping_add.py @@ -0,0 +1,98 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.extensions.tests import\ + utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.tests\ + import utils as fdw_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.\ + foreign_servers.tests import utils as fsrv_utils +from . import utils as um_utils + + +class UserMappingAddTestCase(BaseTestGenerator): + """ + This class will add user mapping under foreign server node. + """ + + scenarios = [ + # Fetching default URL for user mapping node. + ('Check user mapping Node', dict(url='/browser/user_mapping/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add extension(s) to schema(s) + 5. Add foreign data wrapper(s) to extension(s) + 6. Add foreign server(s) to foreign data wrapper(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + # Add schema(s) under connected database(s) + schema_utils.add_schemas(cls.tester) + + # Add extension(s) to schema(s) + extension_utils.add_extensions(cls.tester) + + # Add foreign data wrapper(s) to extension(s) + fdw_utils.add_fdw(cls.tester) + + # Add foreign server(s) to foreign data wrapper + fsrv_utils.add_fsrv(cls.tester) + + def runTest(self): + """ This function will add user mapping under foreign server node. """ + + um_utils.add_um(self.tester) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added user mapping(s), foreign server(s), + foreign data wrapper(s), extension(s), schema(s), database(s), + server(s) and parent id file + + :return: None + """ + + um_utils.delete_um(cls.tester) + fsrv_utils.delete_fsrv(cls.tester) + fdw_utils.delete_fdw(cls.tester) + extension_utils.delete_extension(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/foreign_data_wrappers/foreign_servers/user_mapping/tests/test_user_mapping_delete.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/test_user_mapping_delete.py new file mode 100644 index 0000000..245ba2e --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/test_user_mapping_delete.py @@ -0,0 +1,102 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.extensions.tests import\ + utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.tests \ + import utils as fdw_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.\ + foreign_servers.tests import utils as fsrv_utils +from . import utils as um_utils + + +class UserMappingDeleteTestCase(BaseTestGenerator): + """ + This class will delete user mapping under foreign server node. + """ + + scenarios = [ + # Fetching default URL for user mapping node. + ('Check user mapping Node', dict(url='/browser/user_mapping/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add extension(s) to schema(s) + 5. Add foreign data wrapper(s) to extension(s) + 6. Add foreign server(s) to foreign data wrapper(s) + 7. Add user mapping(s) to foreign server(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + # Add schema(s) under connected database(s) + schema_utils.add_schemas(cls.tester) + + # Add extension(s) to schema(s) + extension_utils.add_extensions(cls.tester) + + # Add foreign data wrapper(s) to extension(s) + fdw_utils.add_fdw(cls.tester) + + # Add foreign server(s) to foreign data wrapper + fsrv_utils.add_fsrv(cls.tester) + + # Add user mapping(s) to foreign server(s) + um_utils.add_um(cls.tester) + + def runTest(self): + """ This function delete user mapping under foreign server node. """ + + delete_respdata = um_utils.delete_um(self.tester) + self.assertTrue(delete_respdata['success'], 1) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added foreign server(s) , + foreign data wrapper(s), extension(s), schema(s), database(s), + server(s) and parent id file + + :return: None + """ + + fsrv_utils.delete_fsrv(cls.tester) + fdw_utils.delete_fdw(cls.tester) + extension_utils.delete_extension(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/foreign_data_wrappers/foreign_servers/user_mapping/tests/test_user_mapping_get.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/test_user_mapping_get.py new file mode 100644 index 0000000..3270e08 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/test_user_mapping_get.py @@ -0,0 +1,120 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.extensions.tests import\ + utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.tests\ + import utils as fdw_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.\ + foreign_servers.tests import utils as fsrv_utils +from . import utils as um_utils + + +class UserMappingGetTestCase(BaseTestGenerator): + """ + This class will add user mapping under foreign server node. + """ + + scenarios = [ + # Fetching default URL for user mapping node. + ('Check user mapping Node', dict(url='/browser/user_mapping/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add extension(s) to schema(s) + 5. Add foreign data wrapper(s) to extension(s) + 6. Add foreign server(s) to foreign data wrapper(s) + 7. Add user mapping(s) to foreign server(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + # Add schema(s) under connected database(s) + schema_utils.add_schemas(cls.tester) + + # Add extension(s) to schema(s) + extension_utils.add_extensions(cls.tester) + + # Add foreign data wrapper(s) to extension(s) + fdw_utils.add_fdw(cls.tester) + + # Add foreign server(s) to foreign data wrapper + fsrv_utils.add_fsrv(cls.tester) + + # Add user mapping(s) to foreign server(s) + um_utils.add_um(cls.tester) + + def runTest(self): + """ This function will fetch user mapping added to foreign server + node. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + fdw_ids_dict = all_id["fid"][0] + fsrv_ids_dict = all_id["fsid"][0] + um_ids_dict = all_id["umid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + fdw_id = fdw_ids_dict[server_id] + fsrv_id = fsrv_ids_dict[server_id] + um_id = um_ids_dict[server_id] + + response = um_utils.verify_um(self.tester, utils.SERVER_GROUP, + server_id, db_id, + fdw_id, fsrv_id, um_id) + + self.assertEquals(response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """ + This function delete the added foreign server(s) , + foreign data wrapper(s), extension(s), schema(s), database(s), + server(s) and parent id file + + :return: None + """ + + um_utils.delete_um(cls.tester) + fsrv_utils.delete_fsrv(cls.tester) + fdw_utils.delete_fdw(cls.tester) + extension_utils.delete_extension(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/foreign_data_wrappers/foreign_servers/user_mapping/tests/test_user_mapping_put.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/test_user_mapping_put.py new file mode 100644 index 0000000..9aa9a30 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/test_user_mapping_put.py @@ -0,0 +1,138 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.extensions.tests import\ + utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.tests \ + import utils as fdw_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.\ + foreign_servers.tests import utils as fsrv_utils +from . import utils as um_utils +from regression.test_setup import advanced_config_data +import json + + +class UserMappingPutTestCase(BaseTestGenerator): + """ + This class will update user mapping under foreign server node. + """ + + scenarios = [ + # Fetching default URL for user mapping node. + ('Check user mapping Node', dict(url='/browser/user_mapping/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add extension(s) to schema(s) + 5. Add foreign data wrapper(s) to extension(s) + 6. Add foreign server(s) to foreign data wrapper(s) + 7. Add user mapping(s) to foreign server(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + + # Add schema(s) under connected database(s) + schema_utils.add_schemas(cls.tester) + + # Add extension(s) to schema(s) + extension_utils.add_extensions(cls.tester) + + # Add foreign data wrapper(s) to extension(s) + fdw_utils.add_fdw(cls.tester) + + # Add foreign server(s) to foreign data wrapper + fsrv_utils.add_fsrv(cls.tester) + + # Add user mapping(s) to foreign server(s) + um_utils.add_um(cls.tester) + + def runTest(self): + """ This function update user mapping under foreign server node. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + fdw_ids_dict = all_id["fid"][0] + fsrv_ids_dict = all_id["fsid"][0] + um_ids_dict = all_id["umid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + fdw_id = fdw_ids_dict[server_id] + fsrv_id = fsrv_ids_dict[server_id] + um_id = um_ids_dict[server_id] + + response = um_utils.verify_um(self.tester, utils.SERVER_GROUP, + server_id, db_id, + fdw_id, fsrv_id, um_id) + if response.status_code == 200: + + data = \ + { + "id": um_id, + "umoptions": + advanced_config_data['user_mapping_update_data'] + ['options'] + } + + put_response = self.tester.put( + self.url + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(fdw_id) + '/' + + str(fsrv_id) + '/' + str(um_id), + data=json.dumps(data), + follow_redirects=True) + + self.assertEquals(put_response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added foreign server(s) , + foreign data wrapper(s), extension(s), schema(s), database(s), + server(s) and parent id file + + :return: None + """ + + um_utils.delete_um(cls.tester) + fsrv_utils.delete_fsrv(cls.tester) + fdw_utils.delete_fdw(cls.tester) + extension_utils.delete_extension(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/foreign_data_wrappers/foreign_servers/user_mapping/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/utils.py new file mode 100644 index 0000000..8349222 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/foreign_servers/user_mapping/tests/utils.py @@ -0,0 +1,156 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import os +import pickle +import json +from regression.test_setup import advanced_config_data, pickle_path +from regression import test_utils as utils +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.foreign_data_wrappers.tests \ + import utils as fdw_utils +from pgadmin.browser.server_groups.servers.databases.foreign_data_wrappers.\ + foreign_servers.tests import utils as fsrv_utils + + +UM_URL = '/browser/user_mapping/obj/' + + +def get_um_config_data(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['user_mapping_credentials']: + if db_user == config_test_data['owner']: + adv_config_data = config_test_data + + data = { + "name": adv_config_data['name'], + "um_options": adv_config_data['option'], + "umoptions": adv_config_data['options'] + } + + return data + + +def add_um(tester): + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + fdw_ids_dict = all_id["fid"][0] + fsrv_ids_dict = all_id["fsid"][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) + + fdw_id = fdw_ids_dict[server_id] + + fdw_response = fdw_utils.verify_fdws(tester, + utils.SERVER_GROUP, + server_id, db_id, + fdw_id) + + fsrv_id = fsrv_ids_dict[server_id] + + fsrv_response = fsrv_utils.verify_fsrv(tester, utils.SERVER_GROUP, + server_id, db_id, + fdw_id, fsrv_id) + + if fsrv_response.status_code == 200: + data = get_um_config_data(server_connect_response) + + response = tester.post( + UM_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str( + db_id) + + '/' + str(fdw_id) + '/' + str(fsrv_id) + '/', + data=json.dumps(data), + content_type='html/json') + + assert response.status_code == 200 + + response_data = json.loads(response.data.decode()) + write_um_info(response_data, server_id) + + +def write_um_info(response_data, server_id): + """ + This function writes the schema id into parent_id.pkl + + :param response_data: foreign server add response data + :type response_data: dict + :param server_id: server id + :type server_id: str + :return: None + """ + + um_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 'umid' in pickle_id_dict: + if pickle_id_dict['umid']: + # Add the umid as value in dict + pickle_id_dict["umid"][0].update({server_id: um_id}) + else: + # Create new dict with server_id and umid + pickle_id_dict["umid"].append({server_id: um_id}) + fsrv_output = open(pickle_path, 'wb') + pickle.dump(pickle_id_dict, fsrv_output) + fsrv_output.close() + + +def verify_um(tester, server_group, server_id, db_id, fdw_id, fsrv_id, um_id): + response = tester.get(UM_URL + str(server_group) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(fdw_id) + '/' + str(fsrv_id) + '/' + str( + um_id), + content_type='html/json') + return response + + +def delete_um(tester): + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + fdw_ids_dict = all_id["fid"][0] + fsrv_ids_dict = all_id["fsid"][0] + um_ids_dict = all_id["umid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + fdw_id = fdw_ids_dict[server_id] + fsrv_id = fsrv_ids_dict[server_id] + um_id = um_ids_dict[server_id] + + response = verify_um(tester, utils.SERVER_GROUP, + server_id, db_id, + fdw_id, fsrv_id, um_id) + if response.status_code == 200: + delete_response = tester.delete( + UM_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(fdw_id) + '/' + + str(fsrv_id) + '/' + str(um_id), + follow_redirects=True) + delete_respdata = json.loads(delete_response.data.decode()) + return delete_respdata diff --git a/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/__init__.py new file mode 100644 index 0000000..6f9f064 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/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 FDWGeneratorTestCase(BaseTestGenerator): + + def runTest(self): + return [] \ No newline at end of file diff --git a/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/test_FDW_add.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/test_FDW_add.py new file mode 100644 index 0000000..af1bfd4 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/test_FDW_add.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 pgadmin.utils.route import BaseTestGenerator +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.extensions.tests import\ + utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from . import utils as fdw_utils + + +class FDWDAddTestCase(BaseTestGenerator): + """ This class will add foreign data wrappers under database node. """ + + scenarios = [ + # Fetching default URL for foreign_data_wrapper node. + ('Check FDW Node', + dict(url='/browser/foreign_data_wrapper/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schema(s) to connected database(s) + 4. Add extension(s) to schema(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + schema_utils.add_schemas(cls.tester) + + extension_utils.add_extensions(cls.tester) + + def runTest(self): + """ This function will add extension under 1st server of tree node. """ + fdw_utils.add_fdw(self.tester) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + """ + + fdw_utils.delete_fdw(cls.tester) + extension_utils.delete_extension(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/foreign_data_wrappers/tests/test_FDW_delete.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/test_FDW_delete.py new file mode 100644 index 0000000..59a7f1f --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/test_FDW_delete.py @@ -0,0 +1,79 @@ +################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.extensions.tests import\ + utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from . import utils as fdw_utils +import json + + +class FDWDDeleteTestCase(BaseTestGenerator): + """ This class will delete foreign data wrappers under database node. """ + + scenarios = [ + # Fetching default URL for foreign_data_wrapper node. + ('Check FDW Node', + dict(url='/browser/foreign_data_wrapper/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the following tasks: + 1. Add and connect to the test server(s) + 2. Add database(s) connected to server(s) + 3. Add schemas to connected database(s) + 4. Add extension(s) to schema(s) + 5. Add foreign data wrapper(s) to extension(s) + + :return: None + """ + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + schema_utils.add_schemas(cls.tester) + + extension_utils.add_extensions(cls.tester) + + fdw_utils.add_fdw(cls.tester) + + def runTest(self): + """ This function will delete added FDW. """ + + delete_respdata = fdw_utils.delete_fdw(self.tester) + self.assertTrue(delete_respdata['success'], 1) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + """ + extension_utils.delete_extension(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/foreign_data_wrappers/tests/test_FDW_get.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/test_FDW_get.py new file mode 100644 index 0000000..ebea93e --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/test_FDW_get.py @@ -0,0 +1,83 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.extensions.tests import\ + utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from . import utils as fdw_utils + + +class FDWDGetTestCase(BaseTestGenerator): + """ This class will add foreign data wrappers under database node. """ + + scenarios = [ + # Fetching default URL for foreign_data_wrapper node. + ('Check FDW Node', + dict(url='/browser/foreign_data_wrapper/obj/')) + ] + + @classmethod + def setUpClass(cls): + """This function use to add/connect the servers and create databases""" + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + schema_utils.add_schemas(cls.tester) + + extension_utils.add_extensions(cls.tester) + + fdw_utils.add_fdw(cls.tester) + + def runTest(self): + """ This function will get added FDW. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + fdw_ids_dict = all_id["fid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + fdw_id = fdw_ids_dict[server_id] + + response = fdw_utils.verify_fdws(self.tester, + utils.SERVER_GROUP, + server_id, db_id, + fdw_id) + + self.assertEquals(response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """This function deletes the added schema, database, server and parent + id file + """ + fdw_utils.delete_fdw(cls.tester) + extension_utils.delete_extension(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/foreign_data_wrappers/tests/test_FDW_put.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/test_FDW_put.py new file mode 100644 index 0000000..96c35f6 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/test_FDW_put.py @@ -0,0 +1,101 @@ +# ################################################################# +# +# 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 +from regression import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.extensions.tests import\ + utils as extension_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from . import utils as fdw_utils +from regression.test_setup import advanced_config_data +import json + + +class FDWDPutTestCase(BaseTestGenerator): + """ This class will add foreign data wrappers under database node. """ + + scenarios = [ + # Fetching default URL for foreign_data_wrapper node. + ('Check FDW Node', + dict(url='/browser/foreign_data_wrapper/obj/')) + ] + + @classmethod + def setUpClass(cls): + """This function use to add/connect the servers and create databases""" + + # Add the server + server_utils.add_server(cls.tester) + + # Connect to servers + 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 databases to connected servers + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + schema_utils.add_schemas(cls.tester) + + extension_utils.add_extensions(cls.tester) + + fdw_utils.add_fdw(cls.tester) + + def runTest(self): + """ This function will update added FDW. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + fdw_ids_dict = all_id["fid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + fdw_id = fdw_ids_dict[server_id] + + response = fdw_utils.verify_fdws(self.tester, + utils.SERVER_GROUP, + server_id, db_id, + fdw_id) + + if response.status_code == 200: + data = \ + { + "description": advanced_config_data['fdw_update_data'] + ['comment'], + "id": fdw_id + } + + put_response = self.tester.put( + self.url + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + + str(db_id) + '/' + str(fdw_id), + data=json.dumps(data), + follow_redirects=True) + + self.assertEquals(put_response.status_code, 200) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added schema, database, server and parent + id file + """ + fdw_utils.delete_fdw(cls.tester) + extension_utils.delete_extension(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/foreign_data_wrappers/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/utils.py new file mode 100644 index 0000000..64782c0 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/foreign_data_wrappers/tests/utils.py @@ -0,0 +1,133 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import os +import pickle +import json +from regression.test_setup import advanced_config_data, pickle_path +from regression import test_utils as utils +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 +import uuid + +FDW_URL = '/browser/foreign_data_wrapper/obj/' + + +def get_fdw_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['fdw_credentials']: + if db_user == config_test_data['owner']: + adv_config_data = config_test_data + + data = { + "fdwacl": adv_config_data['acl'], + "fdwhan": "{0}.{1}".format(schema_name, adv_config_data['handler']), + "fdwoptions": adv_config_data['options'], + "fdwowner": adv_config_data['owner'], + "fdwvalue": "{0}.{1}".format(schema_name, adv_config_data['validator']), + "name": "fdw_{}".format(str(uuid.uuid4())[1:4]) + } + + return data + + +def add_fdw(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_fdw_config_data(schema_name, + server_connect_response) + + response = tester.post(FDW_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + '/', + data=json.dumps(data), + content_type='html/json') + assert response.status_code == 200 + response_data = json.loads(response.data.decode('utf-8')) + write_fdw_info(response_data, server_id) + + +def write_fdw_info(response_data, server_id): + """ + This function writes the sequence id into parent_id.pkl + + :param response_data: FDW add response data + :type response_data: dict + :param server_id: server id + :type server_id: str + :return: None + """ + + fdw_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['fid']: + # Add the FDW_id as value in dict + pickle_id_dict["fid"][0].update({server_id: fdw_id}) + else: + # Create new dict with server_id and FDW_id + pickle_id_dict["fid"].append({server_id: fdw_id}) + fdw_output = open(pickle_path, 'wb') + pickle.dump(pickle_id_dict, fdw_output) + fdw_output.close() + + +def verify_fdws(tester, server_group, server_id, db_id, fdw_id): + response = tester.get(FDW_URL + str(server_group) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(fdw_id), + content_type='html/json') + return response + + +def delete_fdw(tester): + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + fdw_ids_dict = all_id["fid"][0] + + for server_id in server_ids: + db_id = db_ids_dict[int(server_id)] + fdw_id = fdw_ids_dict[server_id] + + response = verify_fdws(tester, + utils.SERVER_GROUP, + server_id, db_id, + fdw_id) + + if response.status_code == 200: + delete_response = tester.delete( + FDW_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + + str(db_id) + '/' + str(fdw_id), + follow_redirects=True) + + delete_respdata = json.loads(delete_response.data.decode()) + + return delete_respdata