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 index 7a11ed5..5d615d0 100644 --- 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 @@ -63,7 +63,6 @@ class ExtensionsPutTestCase(BaseTestGenerator): 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)] @@ -75,22 +74,20 @@ class ExtensionsPutTestCase(BaseTestGenerator): extension_id) if response.status_code == 200: - schema_name = schema_info_dict[int(server_id)][1] - - data = \ - { + data = { "id": extension_id, - "schema": schema_name + "schema": "public" } - 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) + else: + raise Exception("Error in verifying extension with id: %s" % + extension_id) @classmethod def tearDownClass(cls): diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/__init__.py new file mode 100644 index 0000000..56cc7f2 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/__init__.py @@ -0,0 +1,8 @@ +########################################################################## +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +########################################################################## diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_add.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_add.py new file mode 100644 index 0000000..061c645 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_add.py @@ -0,0 +1,69 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from . import utils as domain_utils + + +class DomainAddTestCase(BaseTestGenerator): + """ This class will add new domain under schema node. """ + + scenarios = [ + # Fetching default URL for domain node. + ('Fetch domain Node URL', dict(url='/browser/domain/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the three tasks + 1. Add the test server + 2. Connect to server + 3. Add the databases + 4. Add the schemas + + :return: None + """ + + # Firstly, add the server + server_utils.add_server(cls.tester) + # Connect to server + cls.server_connect_response, cls.server_group, cls.server_ids = \ + server_utils.connect_server(cls.tester) + if len(cls.server_connect_response) == 0: + raise Exception("No Server(s) connected to add the database!!!") + # Add database + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + # Add schemas + schema_utils.add_schemas(cls.tester) + + def runTest(self): + """ This function will add domain under schema node. """ + + domain_utils.add_domain(self.tester, self.server_connect_response) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added database, server and the + 'parent_id.pkl' file which is created in setup() function. + + :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/schemas/domains/tests/test_domain_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_delete.py new file mode 100644 index 0000000..da01500 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_delete.py @@ -0,0 +1,130 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import json + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from . import utils as domain_utils + + +class DomainDeleteTestCase(BaseTestGenerator): + """ This class will delete new domain under schema node. """ + + scenarios = [ + # Fetching default URL for domain node. + ('Fetch domain Node URL', dict(url='/browser/domain/delete/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the three tasks + 1. Add the test server + 2. Connect to server + 3. Add the databases + 4. Add the schemas + 5. Add the domain + + :return: None + """ + + # Firstly, add the server + server_utils.add_server(cls.tester) + # Connect to server + cls.server_connect_response, cls.server_group, cls.server_ids = \ + server_utils.connect_server(cls.tester) + if len(cls.server_connect_response) == 0: + raise Exception("No Server(s) connected to add the database!!!") + # Add database + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + # Add schemas + schema_utils.add_schemas(cls.tester) + # Add the domain + domain_utils.add_domain(cls.tester, cls.server_connect_response) + + def runTest(self): + """ This function will delete domain under schema node. """ + + all_id = utils.get_ids() + server_ids_dict = all_id["sid"] + db_ids_dict = all_id["did"][0] + schema_ids_dict = all_id["scid"][0] + domain_ids_dict = all_id["doid"][0] + + for server_id in server_ids_dict: + # Verify server + server_response = server_utils.verify_server( + self.tester, str(utils.SERVER_GROUP), server_id) + if server_response['data']["connected"]: + db_id = db_ids_dict[int(server_id)] + # Verify database + db_con = database_utils.verify_database(self.tester, + utils.SERVER_GROUP, + server_id, db_id) + if db_con['data']["connected"]: + schema_id = schema_ids_dict[int(server_id)][0] + # Verify schema + schema_response = schema_utils.verify_schemas(self.tester, + server_id, + db_id, + schema_id) + if schema_response.status_code == 200: + domain_id = domain_ids_dict[int(server_id)] + # Call GET API to verify the domain + response = domain_utils.verify_domain(self.tester, + server_id, db_id, + schema_id, + domain_id) + + if response.status_code == 200: + delete_response = self.tester.delete( + self.url + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + + str(db_id) + '/' + + str(schema_id) + '/' + + str(domain_id), + follow_redirects=True) + del_resp_data = json.loads( + delete_response.data.decode('utf-8')) + self.assertTrue(del_resp_data['success'], 1) + else: + raise Exception( + "Error in verifying domain with id: %s" % + domain_id) + + else: + raise Exception("Error in verifying schema with id: %s" + % str(schema_id)) + else: + raise Exception("Error in verifying database with id: %s" + % db_id) + + else: + raise Exception("Error in connecting server with id: %s" + % server_id) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added database, server and the + 'parent_id.pkl' file which is created in setup() function. + + :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/schemas/domains/tests/test_domain_get.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_get.py new file mode 100644 index 0000000..36b5ae0 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_get.py @@ -0,0 +1,113 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from . import utils as domain_utils + + +class DomainGetTestCase(BaseTestGenerator): + """ This class will fetch new collation under schema node. """ + + scenarios = [ + # Fetching default URL for domain node. + ('Fetch domain Node URL', dict(url='/browser/domain/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the three tasks + 1. Add the test server + 2. Connect to server + 3. Add the databases + 4. Add the schemas + 5. Add the domain + + :return: None + """ + + # Firstly, add the server + server_utils.add_server(cls.tester) + # Connect to server + cls.server_connect_response, cls.server_group, cls.server_ids = \ + server_utils.connect_server(cls.tester) + if len(cls.server_connect_response) == 0: + raise Exception("No Server(s) connected to add the database!!!") + # Add database + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + # Add schemas + schema_utils.add_schemas(cls.tester) + # Add the domain + domain_utils.add_domain(cls.tester, cls.server_connect_response) + + def runTest(self): + """ This function will add domain under schema node. """ + + all_id = utils.get_ids() + server_ids_dict = all_id["sid"] + db_ids_dict = all_id["did"][0] + schema_ids_dict = all_id["scid"][0] + domain_ids_dict = all_id["doid"][0] + + for server_id in server_ids_dict: + # Verify server + server_response = server_utils.verify_server( + self.tester, str(utils.SERVER_GROUP), server_id) + if server_response['data']["connected"]: + db_id = db_ids_dict[int(server_id)] + # Verify database + db_con = database_utils.verify_database(self.tester, + utils.SERVER_GROUP, + server_id, db_id) + if db_con['data']["connected"]: + schema_id = schema_ids_dict[int(server_id)][0] + # Verify schema + schema_response = schema_utils.verify_schemas(self.tester, + server_id, + db_id, + schema_id) + if schema_response.status_code == 200: + domain_id = domain_ids_dict[int(server_id)] + # Call GET API to verify the domain + response = domain_utils.verify_domain(self.tester, + server_id, db_id, + schema_id, + domain_id) + + self.assertEquals(response.status_code, 200) + else: + raise Exception("Error in verifying schema with id: %s" + % str(schema_id)) + else: + raise Exception("Error in verifying database with id: %s" + % db_id) + + else: + raise Exception("Error in connecting server with id: %s" + % server_id) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added database, server and the + 'parent_id.pkl' file which is created in setup() function. + + :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/schemas/domains/tests/test_domain_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_put.py new file mode 100644 index 0000000..aa1ccc9 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/test_domain_put.py @@ -0,0 +1,136 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import json + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from regression.test_setup import advanced_config_data +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from . import utils as domain_utils + + +class DomainPutTestCase(BaseTestGenerator): + """ This class will fetch new collation under schema node. """ + + scenarios = [ + # Fetching default URL for domain node. + ('Fetch domain Node URL', dict(url='/browser/domain/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the three tasks + 1. Add the test server + 2. Connect to server + 3. Add the databases + 4. Add the schemas + 5. Add the domain + + :return: None + """ + + # Firstly, add the server + server_utils.add_server(cls.tester) + # Connect to server + cls.server_connect_response, cls.server_group, cls.server_ids = \ + server_utils.connect_server(cls.tester) + if len(cls.server_connect_response) == 0: + raise Exception("No Server(s) connected to add the database!!!") + # Add database + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + # Add schemas + schema_utils.add_schemas(cls.tester) + # Add the domain + domain_utils.add_domain(cls.tester, cls.server_connect_response) + + def runTest(self): + """ This function will update domain under schema node. """ + + all_id = utils.get_ids() + server_ids_dict = all_id["sid"] + db_ids_dict = all_id["did"][0] + schema_ids_dict = all_id["scid"][0] + domain_ids_dict = all_id["doid"][0] + + for server_id in server_ids_dict: + # Verify server + server_response = server_utils.verify_server( + self.tester, str(utils.SERVER_GROUP), server_id) + if server_response['data']["connected"]: + db_id = db_ids_dict[int(server_id)] + # Verify database + db_con = database_utils.verify_database(self.tester, + utils.SERVER_GROUP, + server_id, db_id) + if db_con['data']["connected"]: + schema_id = schema_ids_dict[int(server_id)][0] + # Verify schema + schema_response = schema_utils.verify_schemas(self.tester, + server_id, + db_id, + schema_id) + if schema_response.status_code == 200: + domain_id = domain_ids_dict[int(server_id)] + # Call GET API to verify the domain + response = domain_utils.verify_domain(self.tester, + server_id, db_id, + schema_id, + domain_id) + + if response.status_code == 200: + data = {"description": advanced_config_data[ + 'domain_update_data']['comment'], + "id": domain_id, + } + + put_response = self.tester.put( + self.url + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + + str(db_id) + '/' + + str(schema_id) + '/' + + str(domain_id), + data=json.dumps(data), + follow_redirects=True) + + self.assertEquals(put_response.status_code, 200) + else: + raise Exception( + "Error in verifying domain with id: %s" % + domain_id) + + else: + raise Exception("Error in verifying schema with id: %s" + % str(schema_id)) + else: + raise Exception("Error in verifying database with id: %s" + % db_id) + + else: + raise Exception("Error in connecting server with id: %s" + % server_id) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added database, server and the + 'parent_id.pkl' file which is created in setup() function. + + :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/schemas/domains/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/utils.py new file mode 100644 index 0000000..9bab464 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/domains/tests/utils.py @@ -0,0 +1,173 @@ +# ########################################################################## +# +# #pgAdmin 4 - PostgreSQL Tools +# +# #Copyright (C) 2013 - 2016, The pgAdmin Development Team +# #This software is released under the PostgreSQL Licence +# +# ########################################################################## + +import json +import os +import pickle +import uuid + +from regression.test_setup import pickle_path, advanced_config_data +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from regression import test_utils as utils + +DOMAIN_URL = '/browser/domain/obj/' + + +def get_domain_config_data(server_connect_data, schema_name): + """ + This function returns the config data for domain node + :param server_connect_data: server connect response + :type server_connect_data: dict + :param schema_name: schema name under which domain will create + :type schema_name: str + :return data: config data + :rtype: dict + """ + adv_config_data = None + 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['domain_data']: + if db_user == config_test_data['owner']: + adv_config_data = config_test_data + + if adv_config_data is not None: + data = { + "basensp": schema_name, + "basetype": adv_config_data['basetype'], + "collname": adv_config_data['collation'], + "constraints": adv_config_data['constraints'], + "is_tlength": adv_config_data['lenght'], + "max_val": adv_config_data['max_value'], + "min_val": adv_config_data['min_value'], + "name": "test_{}".format(str(uuid.uuid4())[1:8]), + "owner": adv_config_data['owner'], + "seclabels": adv_config_data['security'], + "typdefault": adv_config_data['defalt_type'], + "typlen": adv_config_data['type_len'] + } + return data + + +def write_domain_id(response_data, server_id): + """ + This function writes the server and collation id + + :param response_data: domain response data + :type response_data: dict + :param server_id: server id + :type server_id: int + :return: None + """ + domain_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 'doid' in pickle_id_dict: + if pickle_id_dict['doid']: + # Add the db_id as value in dict + pickle_id_dict["doid"][0].update( + {int(server_id): domain_id}) + else: + # Create new dict with server_id and db_id + pickle_id_dict["doid"].append( + {int(server_id): domain_id}) + db_output = open(pickle_path, 'wb') + pickle.dump(pickle_id_dict, db_output) + db_output.close() + + +def verify_domain(tester, server_id, db_id, schema_id, domain_id): + """ + This function verifies the existing domain using GET method + :param tester: test client + :type tester: flask test client + :param server_id: server id + :type server_id: int + :param db_id: database id + :type db_id: int + :param schema_id: schemna id + :type schema_id: int + :param domain_id: domain id + :type domain_id: int + :return get_response: HTTP GET response + :rtype: dict + """ + get_response = tester.get(DOMAIN_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + + str(db_id) + '/' + + str(schema_id) + '/' + + str(domain_id), + content_type='html/json') + return get_response + + +def add_domain(tester, server_connect_response): + """ + This function is used to add the domain to existing schema + :param tester: test client + :type tester: flask test client object + :param server_connect_response: server connect GET response + :type server_connect_response: dict + :return: None + """ + all_id = utils.get_ids() + server_ids_dict = all_id["sid"] + db_ids_dict = all_id["did"][0] + schema_ids_dict = all_id["scid"][0] + + for server_connect_response, server_id in zip(server_connect_response, + server_ids_dict): + # Verify server + server_response = server_utils.verify_server(tester, + str(utils.SERVER_GROUP), + server_id) + if server_response['data']["connected"]: + db_id = db_ids_dict[int(server_id)] + # Verify database + db_con = database_utils.verify_database(tester, utils.SERVER_GROUP, + server_id, db_id) + if db_con['data']["connected"]: + schema_id = schema_ids_dict[int(server_id)][0] + schema_name = schema_ids_dict[int(server_id)][1] + # Verify schema + schema_response = schema_utils.verify_schemas(tester, + server_id, db_id, + schema_id) + if schema_response.status_code == 200: + data = get_domain_config_data(server_connect_response, schema_name) + # Call POST API to add domain + response = tester.post( + DOMAIN_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(schema_id) + '/', + data=json.dumps(data), + content_type='html/json') + + assert response.status_code == 200 + response_data = json.loads(response.data.decode('utf-8')) + write_domain_id(response_data, server_id) + else: + raise Exception("Error in verifying schema with id: %s" + % str(schema_id)) + else: + raise Exception("Error in verifying database with id: %s" + % db_id) + + else: + raise Exception("Error in connecting server with id: %s" + % server_id) + diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/__init__.py new file mode 100644 index 0000000..56cc7f2 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/__init__.py @@ -0,0 +1,8 @@ +########################################################################## +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +########################################################################## diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_add.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_add.py new file mode 100644 index 0000000..6ff24c9 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_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 regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.tablespaces.tests import utils as \ + tablespace_utils +from . import utils as tables_utils + + +class TableAddTestCase(BaseTestGenerator): + """ This class will add new collation under schema node. """ + + scenarios = [ + # Fetching default URL for table node. + ('Fetch table Node URL', dict(url='/browser/table/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the three tasks + 1. Add the test server + 2. Connect to server + 3. Add the databases + 4. Add the schemas + + :return: None + """ + + # Firstly, 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 tablespace + tablespace_utils.add_table_space(cls.tester, + cls.server_connect_response, + cls.server_group, cls.server_ids) + + # Add database + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + # Add schemas + schema_utils.add_schemas(cls.tester) + + def runTest(self): + """ This function will add table under schema node. """ + + tables_utils.add_tables(self.tester, self.server_connect_response) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added tables, schemas, database, + server and the 'parent_id.pkl' file which is created in setup() + function. + + :return: None + """ + + database_utils.delete_database(cls.tester) + tablespace_utils.delete_table_space(cls.tester) + server_utils.delete_server(cls.tester) + utils.delete_parent_id_file() + diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_delete.py new file mode 100644 index 0000000..3002836 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_delete.py @@ -0,0 +1,82 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## +import json + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.tablespaces.tests import utils as \ + tablespace_utils +from . import utils as tables_utils + + +class TableDeleteTestCase(BaseTestGenerator): + """ This class will delete new table under schema node. """ + + scenarios = [ + # Fetching default URL for table node. + ('Fetch table Node URL', dict(url='/browser/table/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the three tasks + 1. Add the test server + 2. Connect to server + 3. Add the databases + 4. Add the schemas + 5. Add the tables + + :return: None + """ + + # Firstly, 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 tablespace + tablespace_utils.add_table_space(cls.tester, + cls.server_connect_response, + cls.server_group, cls.server_ids) + + # Add database + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + # Add schemas + schema_utils.add_schemas(cls.tester) + # Add tables + tables_utils.add_tables(cls.tester, cls.server_connect_response) + + def runTest(self): + """ This function will delete added table under schema node. """ + + tables_utils.delete_tables(self.tester) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added tables, schemas, database, + server and the 'parent_id.pkl' file which is created in setup() + function. + + :return: None + """ + + database_utils.delete_database(cls.tester) + tablespace_utils.delete_table_space(cls.tester) + server_utils.delete_server(cls.tester) + utils.delete_parent_id_file() \ No newline at end of file diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_get.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_get.py new file mode 100644 index 0000000..683701b --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_get.py @@ -0,0 +1,121 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import json + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.tablespaces.tests import utils as \ + tablespace_utils +from . import utils as tables_utils + + +class TableGetTestCase(BaseTestGenerator): + """ This class will add new collation under schema node. """ + + scenarios = [ + # Fetching default URL for table node. + ('Fetch table Node URL', dict(url='/browser/table/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the three tasks + 1. Add the test server + 2. Connect to server + 3. Add the databases + 4. Add the schemas + 5. Add the tables + + :return: None + """ + + # Firstly, 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 tablespace + tablespace_utils.add_table_space(cls.tester, + cls.server_connect_response, + cls.server_group, cls.server_ids) + + # Add database + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + # Add schemas + schema_utils.add_schemas(cls.tester) + # Add tables + tables_utils.add_tables(cls.tester, cls.server_connect_response) + + def runTest(self): + """ This function will fetch added table under schema node. """ + + all_id = utils.get_ids() + server_ids = all_id["sid"] + db_ids_dict = all_id["did"][0] + schema_ids_dict = all_id["scid"][0] + table_ids_dict = all_id["tid"][0] + + for server_id in server_ids: + server_response = server_utils.verify_server(self.tester, str( + utils.SERVER_GROUP), server_id) + if server_response['data']['connected']: + db_id = db_ids_dict[int(server_id)] + db_con = database_utils.verify_database(self.tester, + utils.SERVER_GROUP, + server_id, db_id) + if db_con['data']['connected']: + schema_id = schema_ids_dict[int(server_id)][0] + schema_response = schema_utils.verify_schemas( + self.tester, server_id, db_id, schema_id) + schema_response = json.loads( + schema_response.data.decode('utf-8')) + if len(schema_response) != 0: + table_id = table_ids_dict[int(server_id)] + get_response = tables_utils.verify_table(self.tester, + server_id, + db_id, + schema_id, + table_id) + self.assertEquals(get_response.status_code, 200) + else: + raise Exception( + "Error while verifying schema with id: %s" + % schema_id) + else: + raise Exception( + "Error while connecting database with id: %s" + % db_id) + else: + raise Exception("Error while connecting server with id: %s" + % server_id) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added tables, schemas, database, + server and the 'parent_id.pkl' file which is created in setup() + function. + + :return: None + """ + + database_utils.delete_database(cls.tester) + tablespace_utils.delete_table_space(cls.tester) + server_utils.delete_server(cls.tester) + utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_put.py new file mode 100644 index 0000000..2a7391b --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/test_table_put.py @@ -0,0 +1,142 @@ +# ################################################################# +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2016, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +# ################################################################## + +import json + +from regression import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from regression.test_setup import advanced_config_data +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.tablespaces.tests import utils as \ + tablespace_utils +from . import utils as tables_utils + + +class TableUpdateTestCase(BaseTestGenerator): + """ This class will add new collation under schema node. """ + + scenarios = [ + # Fetching default URL for table node. + ('Fetch table Node URL', dict(url='/browser/table/obj/')) + ] + + @classmethod + def setUpClass(cls): + """ + This function perform the three tasks + 1. Add the test server + 2. Connect to server + 3. Add the databases + 4. Add the schemas + 5. Add the tables + + :return: None + """ + + # Firstly, 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 tablespace + tablespace_utils.add_table_space(cls.tester, + cls.server_connect_response, + cls.server_group, cls.server_ids) + + # Add database + database_utils.add_database(cls.tester, cls.server_connect_response, + cls.server_ids) + # Add schemas + schema_utils.add_schemas(cls.tester) + # Add tables + tables_utils.add_tables(cls.tester, cls.server_connect_response) + + def runTest(self): + """ This function will fetch added table under schema node. """ + + all_id = utils.get_ids() + server_ids_dict = all_id["sid"] + db_ids_dict = all_id["did"][0] + schema_ids_dict = all_id["scid"][0] + table_ids_dict = all_id["tid"][0] + + for server_id in server_ids_dict: + # Verify server + server_response = server_utils.verify_server( + self.tester, str(utils.SERVER_GROUP), server_id) + if server_response['data']['connected']: + db_id = db_ids_dict[int(server_id)] + # Verify database + db_con = database_utils.verify_database(self.tester, + utils.SERVER_GROUP, + server_id, db_id) + if db_con['data']['connected']: + schema_id = schema_ids_dict[int(server_id)][0] + # Verify schema + schema_response = schema_utils.verify_schemas(self.tester, + server_id, + db_id, + schema_id) + if schema_response.status_code == 200: + table_id = table_ids_dict[int(server_id)] + # Verify table + table_response = tables_utils.verify_table(self.tester, + server_id, + db_id, + schema_id, + table_id) + if table_response.status_code == 200: + data = { + "description": + advanced_config_data['table_update_data']['comment'], + "id": table_id + } + + put_response = self.tester.put( + self.url + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + '/' + + str(schema_id) + '/' + str(table_id), + data=json.dumps(data), follow_redirects=True) + + self.assertEquals(put_response.status_code, 200) + else: + raise Exception("Error while verifying table with " + "id: %s" % table_id) + else: + raise Exception( + "Error while verifying schema with id: %s" + % schema_id) + else: + raise Exception( + "Error while connecting database with id: %s" + % db_id) + else: + raise Exception("Error while connecting server with id: %s" + % server_id) + + @classmethod + def tearDownClass(cls): + """ + This function deletes the added tables, schemas, database, + server and the 'parent_id.pkl' file which is created in setup() + function. + + :return: None + """ + + database_utils.delete_database(cls.tester) + tablespace_utils.delete_table_space(cls.tester) + server_utils.delete_server(cls.tester) + utils.delete_parent_id_file() diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/utils.py new file mode 100644 index 0000000..7458b31 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tables/tests/utils.py @@ -0,0 +1,207 @@ +# ########################################################################## +# +# #pgAdmin 4 - PostgreSQL Tools +# +# #Copyright (C) 2013 - 2016, The pgAdmin Development Team +# #This software is released under the PostgreSQL Licence +# +# ########################################################################## + +import json +import os +import pickle +import uuid + +from regression.test_setup import pickle_path, advanced_config_data +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.tests import utils as server_utils +from regression import test_utils as utils + +TABLES_URL = '/browser/table/obj/' + + +def get_tables_config_data(server_connect_data, schema_name, tablespace_name): + adv_config_data = None + 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['table_credentials']: + if db_user == config_test_data['owner']: + adv_config_data = config_test_data + + if adv_config_data is not None: + data = { + "check_constraint": adv_config_data['constraint'], + "coll_inherits": adv_config_data['col_inherit'], + "columns": adv_config_data['columns'], + "exclude_constraint": adv_config_data['has_constraint'], + "fillfactor": adv_config_data['fillfactor'], + "foreign_key": adv_config_data['has_FK'], + "hastoasttable": adv_config_data['has_toast_tbl'], + "like_constraints": adv_config_data['like_constraint'], + "like_default_value": adv_config_data['like_default_value'], + "like_relation": adv_config_data['like_relation'], + "name": "table_{}".format(str(uuid.uuid4())[1:4]), + "primary_key": adv_config_data['PK'], + "relacl": adv_config_data['acl'], + "relhasoids": adv_config_data['has_oid'], + "relowner": adv_config_data['owner'], + "schema": schema_name, + "seclabels": adv_config_data['sec_acl'], + "spcname": tablespace_name, + "unique_constraint": adv_config_data['unique_constraint'], + "vacuum_table": adv_config_data['vacuum_tbl'], + "vacuum_toast": adv_config_data['vacuum_toast'] + } + return data + + +def write_tables_id(response_data, server_id): + """ + This function writes the server and collation id + + :param response_data: table response data + :type response_data: dict + :param server_id: server id + :type server_id: int + :return: None + """ + + table_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 'tid' in pickle_id_dict: + if pickle_id_dict['tid']: + # Add the db_id as value in dict + pickle_id_dict["tid"][0].update( + {int(server_id): table_id}) + else: + # Create new dict with server_id and db_id + pickle_id_dict["tid"].append( + {int(server_id): table_id}) + db_output = open(pickle_path, 'wb') + pickle.dump(pickle_id_dict, db_output) + db_output.close() + + +def add_tables(tester, server_connect_response): + all_id = utils.get_ids() + server_ids_dict = all_id["sid"] + db_ids_dict = all_id["did"][0] + schema_ids_dict = all_id["scid"][0] + tablespace_ids_dict = None + if "tsid" in all_id and all_id["tsid"]: + tablespace_ids_dict = all_id["tsid"][0] + + for server_connect_response, server_id in zip(server_connect_response, + server_ids_dict): + # Verify server + server_response = server_utils.verify_server(tester, + str(utils.SERVER_GROUP), + server_id) + if server_response['data']["connected"]: + db_id = db_ids_dict[int(server_id)] + # Verify database + db_con = database_utils.verify_database(tester, utils.SERVER_GROUP, + server_id, db_id) + if db_con['data']["connected"]: + schema_id = schema_ids_dict[int(server_id)][0] + schema_name = schema_ids_dict[int(server_id)][1] + # Verify schema + schema_response = schema_utils.verify_schemas(tester, + server_id, db_id, + schema_id) + if schema_response.status_code == 200: + tablespace_name = tablespace_ids_dict[int(server_id)][1] + data = get_tables_config_data(server_connect_response, + schema_name, tablespace_name) + # Add table + response = tester.post( + TABLES_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id) + + '/' + str(schema_id) + '/', + data=json.dumps(data), + content_type='html/json') + assert response.status_code == 200 + response_data = json.loads(response.data.decode('utf-8')) + write_tables_id(response_data, server_id) + else: + raise Exception("Error while verifying schema with id: %s" + % schema_id) + else: + raise Exception("Error while connecting database with id: %s" + % db_id) + else: + raise Exception("Error while connecting server with id: %s" + % server_id) + + +def verify_table(tester, server_id, db_id, schema_id, table_id): + get_response = tester.get(TABLES_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + + str(db_id) + '/' + + str(schema_id) + '/' + + str(table_id), + content_type='html/json') + return get_response + + +def delete_tables(tester): + all_id = utils.get_ids() + server_ids_dict = all_id["sid"] + db_ids_dict = all_id["did"][0] + schema_ids_dict = all_id["scid"][0] + table_ids_dict = all_id["tid"][0] + + for server_id in server_ids_dict: + # Verify server + server_response = server_utils.verify_server(tester, + str(utils.SERVER_GROUP), + server_id) + if server_response['data']['connected']: + db_id = db_ids_dict[int(server_id)] + # Verify database + db_con = database_utils.verify_database(tester, utils.SERVER_GROUP, + server_id, db_id) + if db_con['data']['connected']: + schema_id = schema_ids_dict[int(server_id)][0] + # Verify schema + schema_response = schema_utils.verify_schemas(tester, + server_id, db_id, + schema_id) + if schema_response.status_code == 200: + table_id = table_ids_dict[int(server_id)] + # Verify table + table_response = verify_table(tester, server_id, db_id, + schema_id, table_id) + if table_response.status_code == 200: + # Delete table + del_response = tester.delete( + '/browser/table/delete/' + str(utils.SERVER_GROUP) + + '/' + str(server_id) + '/' + + str(db_id) + '/' + + str(schema_id) + '/' + + str(table_id), + follow_redirects=True) + + del_respdata = json.loads( + del_response.data.decode('utf-8')) + assert del_respdata['success'] == 1 + else: + raise Exception("Error while verifying table") + else: + raise Exception("Error while verifying schema with id: %s" + % schema_id) + else: + raise Exception("Error while connecting database with id: %s" + % db_id) + else: + raise Exception("Error while connecting server with id: %s" + % server_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/test_schema_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/test_schema_put.py index d3d4bfd..967b614 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/test_schema_put.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/tests/test_schema_put.py @@ -94,8 +94,6 @@ class SchemaPutTestCase(BaseTestGenerator): data=json.dumps(data), follow_redirects=True) self.assertEquals(put_response.status_code, 200) - response_data = json.loads(put_response.data.decode('utf-8')) - self.assertTrue(response_data['success'], 1) @classmethod def tearDownClass(cls): diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py index 490e7d9..30972e5 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py +++ b/web/pgadmin/browser/server_groups/servers/databases/tests/test_db_add.py @@ -41,7 +41,7 @@ class DatabaseAddTestCase(BaseTestGenerator): server_utils.connect_server(cls.tester) if len(cls.server_connect_response) == 0: - raise Exception("No Server(s) connected to add the database!!!") + raise Exception("No Server(s) connected to add the database.") def runTest(self): """ This function will add database under 1st server of tree node. """ diff --git a/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py index 37a95ba..c82af99 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py +++ b/web/pgadmin/browser/server_groups/servers/databases/tests/utils.py @@ -16,7 +16,6 @@ from regression.test_setup import pickle_path, advanced_config_data from pgadmin.browser.server_groups.servers.tests import utils as server_utils from regression import test_utils as utils - DATABASE_URL = '/browser/database/obj/' DATABASE_CONNECT_URL = 'browser/database/connect/' @@ -104,12 +103,14 @@ def add_database(tester, server_connect_response, server_ids): if server_connect['data']['connected']: data = get_db_data(server_connect) db_response = tester.post(DATABASE_URL + str(utils.SERVER_GROUP) + - "/" + server_id + "/", - data=json.dumps(data), - content_type='html/json') + "/" + server_id + "/", + data=json.dumps(data), + content_type='html/json') assert db_response.status_code == 200 response_data = json.loads(db_response.data.decode('utf-8')) write_db_id(response_data) + else: + raise Exception("Error in connecting server..") def verify_database(tester, server_group, server_id, db_id): @@ -158,19 +159,24 @@ def delete_database(tester): if all_id['did']: db_ids_dict = all_id['did'][0] else: - raise Exception("Keys are not found in pickle dict: {}".format(["sid", "did"])) + raise Exception( + "Keys are not found in pickle dict: {}".format(["sid", "did"])) if server_ids and db_ids_dict is not None: for server_id in server_ids: - server_response = server_utils.verify_server(tester, utils.SERVER_GROUP, server_id) + server_response = server_utils.verify_server(tester, + utils.SERVER_GROUP, + server_id) if server_response["data"]["connected"]: db_id = db_ids_dict[int(server_id)] - response = tester.delete(DATABASE_URL + str(utils.SERVER_GROUP) + '/' + - str(server_id) + '/' + str(db_id), - follow_redirects=True) + + response = tester.delete( + DATABASE_URL + str(utils.SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id), + follow_redirects=True) assert response.status_code == 200 response_data = json.loads(response.data.decode('utf-8')) assert response_data['success'] == 1 + else: raise Exception("No servers/databases found.") - diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py index b26d71d..3b8a70f 100644 --- a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py +++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_get.py @@ -55,7 +55,7 @@ class TablespaceGetTestCase(BaseTestGenerator): if tablespace_ids_dict: for server_id in server_ids: - tablespace_id = tablespace_ids_dict[int(server_id)] + tablespace_id = tablespace_ids_dict[int(server_id)][0] server_response = server_utils.verify_server(self.tester, utils.SERVER_GROUP, server_id) diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py index 22257f9..a742ee2 100644 --- a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py +++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/test_tbspc_put.py @@ -58,7 +58,7 @@ class TableSpaceUpdateTestCase(BaseTestGenerator): if tablespace_ids_dict: for server_id in server_ids: - tablespace_id = tablespace_ids_dict[int(server_id)] + tablespace_id = tablespace_ids_dict[int(server_id)][0] tablespace_response = tablespace_utils.verify_table_space( self.tester, utils.SERVER_GROUP, server_id, diff --git a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py index 4fd21bd..6cac7ee 100644 --- a/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py +++ b/web/pgadmin/browser/server_groups/servers/tablespaces/tests/utils.py @@ -46,7 +46,7 @@ def get_tablespace_data(server_connect): if adv_config_data is not None: data = { - "name": str(uuid.uuid4())[1:8], + "name": "test_{}".format(str(uuid.uuid4())[1:8]), "seclabels": adv_config_data["spc_seclable"], "spcacl": adv_config_data["spc_acl"], "spclocation": adv_config_data["spc_location"], @@ -56,12 +56,14 @@ def get_tablespace_data(server_connect): return data -def write_tablespace_id(response_data): +def write_tablespace_info(response_data, tablespace_name): """ This function write the table space id to parent_id.pkl :param response_data: create table space API response data :type response_data: dict + :param tablespace_name: tablespace name + :type tablespace_name: str :return: None """ @@ -76,11 +78,11 @@ def write_tablespace_id(response_data): if pickle_id_dict['tsid']: # Add the db_id as value in dict pickle_id_dict["tsid"][0].update( - {server_id: table_space_id}) + {server_id: [table_space_id, tablespace_name]}) else: # Create new dict with server_id and db_id pickle_id_dict["tsid"].append( - {server_id: table_space_id}) + {server_id: [table_space_id, tablespace_name]}) db_output = open(pickle_path, 'wb') pickle.dump(pickle_id_dict, db_output) db_output.close() @@ -125,13 +127,19 @@ def add_table_space(tester, server_connect_response, server_group, server_ids): if server_connect['data']['connected']: data = get_tablespace_data(server_connect) + tablespace_name = '' + if 'name' in data: + tablespace_name = data['name'] response = tester.post(TABLE_SPACE_URL + str(server_group) + '/' + server_id + '/', data=json.dumps(data), content_type='html/json') assert response.status_code == 200 response_data = json.loads(response.data.decode('utf-8')) - write_tablespace_id(response_data) + write_tablespace_info(response_data, tablespace_name) + else: + raise Exception("Error while connecting server with id: %s" + % server_id) def verify_table_space(tester, server_group, server_id, tablespace_id): @@ -173,14 +181,12 @@ def delete_table_space(tester): all_id = utils.get_ids() server_ids = all_id["sid"] + tablespace_ids_dict = None if "tsid" in all_id and all_id["tsid"]: tablespace_ids_dict = all_id["tsid"][0] - else: - tablespace_ids_dict = None - if tablespace_ids_dict is not None: for server_id in server_ids: - tablespace_id = tablespace_ids_dict[int(server_id)] + tablespace_id = tablespace_ids_dict[int(server_id)][0] role_response = verify_table_space(tester, utils.SERVER_GROUP, server_id, tablespace_id) diff --git a/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py b/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py index 9ac6468..fe91299 100644 --- a/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py +++ b/web/pgadmin/browser/server_groups/servers/tests/test_server_put.py @@ -61,9 +61,6 @@ class ServerUpdateTestCase(BaseTestGenerator): content_type='html/json') self.assertEquals(put_response.status_code, 200) - response_data = json.loads(put_response.data.decode()) - self.assertTrue(response_data['success'], 1) - @classmethod def tearDownClass(cls): """ diff --git a/web/pgadmin/browser/server_groups/servers/tests/utils.py b/web/pgadmin/browser/server_groups/servers/tests/utils.py index 6e3f166..6dc7a9f 100644 --- a/web/pgadmin/browser/server_groups/servers/tests/utils.py +++ b/web/pgadmin/browser/server_groups/servers/tests/utils.py @@ -84,8 +84,6 @@ def connect_server(tester): :param tester:test client object :type tester: flask test object - :param add_db_flag: flag for db add test case - :type add_db_flag: bool :return: server_connect, server_group, server_id :rtype: server_connect:dict, server_group:dict, server_id:str """ diff --git a/web/pgadmin/browser/tests/test_change_password.py b/web/pgadmin/browser/tests/test_change_password.py index 5b7c918..2ed7bc8 100644 --- a/web/pgadmin/browser/tests/test_change_password.py +++ b/web/pgadmin/browser/tests/test_change_password.py @@ -88,6 +88,7 @@ class ChangePasswordTestCase(BaseTestGenerator): email=self.username, newPassword=self.password, confirmPassword=self.password, active=1, role="2"), follow_redirects=True) + assert response.status_code == 200 user_id = json.loads(response.data.decode('utf-8'))['id'] # Logout the Administrator before login normal user diff --git a/web/pgadmin/utils/route.py b/web/pgadmin/utils/route.py index 0226e8d..35b9d97 100644 --- a/web/pgadmin/utils/route.py +++ b/web/pgadmin/utils/route.py @@ -56,7 +56,8 @@ class TestsGeneratorRegistry(ABCMeta): if config.SERVER_MODE: for module_name in find_modules(pkg, False, True): try: - module = import_module(module_name) + if "tests." in str(module_name): + module = import_module(module_name) except ImportError: pass else: diff --git a/web/regression/runtests.py b/web/regression/runtests.py index d11a794..7c2c89a 100644 --- a/web/regression/runtests.py +++ b/web/regression/runtests.py @@ -32,7 +32,8 @@ import config # Get the config database schema version. We store this in pgadmin.model # as it turns out that putting it in the config files isn't a great idea from pgadmin.model import SCHEMA_VERSION -from test_utils import login_tester_account, logout_tester_account +from test_utils import login_tester_account, logout_tester_account, \ + drop_objects config.SETTINGS_SCHEMA_VERSION = SCHEMA_VERSION @@ -148,6 +149,9 @@ if __name__ == '__main__': tests = unittest.TextTestRunner(stream=sys.stderr, descriptions=True, verbosity=2).run(suite) + # Drop all objects which are created for testing + drop_objects(test_client) + # Logout the test client logout_tester_account(test_client) diff --git a/web/regression/test_advanced_config.json.in b/web/regression/test_advanced_config.json.in index b339c92..e737610 100644 --- a/web/regression/test_advanced_config.json.in +++ b/web/regression/test_advanced_config.json.in @@ -140,10 +140,10 @@ "spc_opts": [], "spc_user": "postgres" }], - - "tbspc_update_data": { + "tbspc_update_data": { "comment": "This is tablespace update comment" }, + "schema_credentials":[ { "func_acl": [], @@ -296,13 +296,11 @@ "owner": "postgres", "schema": "" }], - - "collation_update_data": { + "collation_update_data": { "comment": "This is collation update comment" }, - "casts_credentials": - [{ + "casts_credentials": [{ "cast_context": "IMPLICIT", "encoding": "UTF8", "name": "money->bigint", @@ -310,9 +308,7 @@ "target_type": "bigint", "owner": "postgres" }], - - "cast_update_data": - { + "cast_update_data": { "comment": "This is cast update comment" }, @@ -324,13 +320,11 @@ "version": "1.0", "owner": "postgres" }], - - "extension_update_data": - { + "extension_update_data": { "schema": "schema" }, - "fdw_credentials":[ + "fdw_credentials":[ { "acl": [ @@ -353,13 +347,11 @@ "validator": "postgres_fdw_validator", "name": "fdw" }], - - "fdw_update_data": - { + "fdw_update_data": { "comment": "This is FDW update comment" }, - "fsrv_credentials":[ + "fsrv_credentials":[ { "fsrv_acl": [ @@ -394,9 +386,7 @@ "owner": "postgres", "name": "foreign_server1" }], - - "FSRV_update_data": - { + "FSRV_update_data": { "comment": "This is foreign server update comment" }, @@ -417,9 +407,7 @@ } ] }], - - "user_mapping_update_data": - { + "user_mapping_update_data": { "options": { "changed": @@ -431,8 +419,7 @@ } }, - "event_trigger_credentials": - [{ + "event_trigger_credentials": [{ "enable": "O", "event_func": "test_schema.test_abort_any_command", "event_name": "DDL_COMMAND_END", @@ -440,57 +427,198 @@ "name": "test_event_trg", "provider": [] }], - - "event_trigger_update_data": - { + "event_trigger_update_data":{ "comment": "This is event trigger update comment" }, - - "sequence_credentials": - [{ - "cache": "1", - "cycled": true, - "increment": "1", - "max_value": "100000", - "min_value": "1", - "name": "test_empno", - "acl": + + "sequence_credentials": [{ + "cache": "1", + "cycled": true, + "increment": "1", + "max_value": "100000", + "min_value": "1", + "name": "test_empno", + "acl": + [ + { + "grantee":"postgres", + "grantor":"postgres", + "privileges": + [ + { + "privilege_type":"r", + "privilege":true, + "with_grant":false + }, + { + "privilege_type":"w", + "privilege":true, + "with_grant":false + }, + { + "privilege_type":"U", + "privilege":true, + "with_grant":false + } + ] + } + ], + "schema_name": "test_schema", + "security": [], + "owner": "postgres", + "start_val": "100" +}], + "sequnce_update_data": { + "comment": "This is sequence update comment" + }, + + "domain_data":[ + { + "schema": "test_schema", + "basetype": "character", + "collation": "pg_catalog.\"POSIX\"", + "constraints": [ { + "conname":"num", + "convalidated":true + } + ], + "lenght": true, + "max_value": 2147483647, + "min_value": 1, + "name": "test_domain", + "owner": "postgres", + "security": [], + "defalt_type": "1", + "type_len": "10" + }], + "domain_update_data": { + "comment": "This is domain update comment" + }, + + "table_credentials":[ + { + "constraint": [], + "col_inherit": "[]", + "columns": [ + { + "name":"empno", + "cltype":"numeric", + "attacl":[], + "is_primary_key":false, + "attoptions":[], + "seclabels":[] + }, + { + "name":"empname", + "cltype":"character[]", + "attacl":[], + "is_primary_key":false, + "attoptions":[], + "seclabels":[] + }, + {"name":"DOJ", + "cltype":"date[]", + "attacl":[], + "is_primary_key":false, + "attoptions":[], + "seclabels":[] + } + ], + "has_constraint": [], + "fillfactor": "11", + "has_FK": [], + "has_toast_tbl": true, + "like_constraint": true, + "like_default_value": true, + "like_relation": "pg_catalog.pg_tables", + "name": "emp", + "PK": [], + "acl": [ + { "grantee":"postgres", "grantor":"postgres", "privileges": [ { - "privilege_type":"r", + "privilege_type":"a", "privilege":true, - "with_grant":false + "with_grant":true }, { - "privilege_type":"w", + "privilege_type":"r", "privilege":true, "with_grant":false }, { - "privilege_type":"U", + "privilege_type":"w", "privilege":true, "with_grant":false } ] } ], - "schema_name": "test_schema", - "security": [], + "has_oid": true, "owner": "postgres", - "start_val": "100" + "schema": "test_schema", + "sec_acl": [], + "tbscp": "pg_default", + "unique_constraint": [], + "vacuum_tbl": [ + { + "name":"autovacuum_analyze_scale_factor" + }, + { + "name":"autovacuum_analyze_threshold" + }, + { + "name":"autovacuum_freeze_max_age" + }, + { + "name":"autovacuum_vacuum_cost_delay" + }, + { + "name":"autovacuum_vacuum_cost_limit" + }, + { + "name":"autovacuum_vacuum_scale_factor" + }, + { + "name":"autovacuum_vacuum_threshold" + }, + { + "name":"autovacuum_freeze_min_age" + }, + { + "name":"autovacuum_freeze_table_age" + } + ], + "vacuum_toast": [ + { + "name":"autovacuum_freeze_max_age" + }, + { + "name":"autovacuum_vacuum_cost_delay" + }, + { + "name":"autovacuum_vacuum_cost_limit" + }, + { + "name":"autovacuum_vacuum_scale_factor" + }, + { + "name":"autovacuum_vacuum_threshold" + }, + { + "name":"autovacuum_freeze_min_age" + }, + { + "name":"autovacuum_freeze_table_age" + } + ] }], - - "sequnce_update_data": - { - "comment": "This is sequence update comment" + "table_update_data": { + "comment": "This is table update comment" } - - - } - - +} diff --git a/web/regression/test_utils.py b/web/regression/test_utils.py index e078eaa..355ceb1 100644 --- a/web/regression/test_utils.py +++ b/web/regression/test_utils.py @@ -9,6 +9,7 @@ import os import pickle + from test_setup import config_data, pickle_path @@ -27,12 +28,14 @@ def get_pickle_id_dict(): "tfnid": [], # trigger functions "coid": [], # collation "cid": [], # casts - "etid": [], # event_trigger + "etid": [], # event_trigger "eid": [], # extension "fid": [], # FDW "fsid": [], # FRS "umid": [], # user_mapping - "seid": [] # sequence + "seid": [], # sequence + "doid": [], # Domain + "tid": [] # table } return pickle_id_dict @@ -47,28 +50,11 @@ def get_ids(url=pickle_path): :rtype: dict """ - output = open(url, 'rb') - ids = pickle.load(output) - output.close() - return ids - - -# def test_getnodes(tester=None): -# # Connect to server and database. -# -# if not tester: -# return None -# -# all_id = get_ids() -# -# server_ids = all_id["sid"] -# db_ids_dict = all_id["did"][0] -# -# db_con = [] -# for server_id in server_ids: -# db_id = db_ids_dict[int(server_id)] -# db_con.append(verify_database(tester, SERVER_GROUP, server_id, db_id)) -# return db_con + if os.path.isfile(url): + output = open(url, 'rb') + ids = pickle.load(output) + output.close() + return ids def login_tester_account(tester): @@ -157,7 +143,56 @@ def delete_parent_id_file(): :return: None """ - if os.path.isfile(pickle_path): os.remove(pickle_path) + +def drop_objects(tester): + if os.path.isfile(pickle_path): + db_url = '/browser/database/obj/' + table_space_url = '/browser/tablespace/obj/' + role_url = '/browser/role/obj/' + server_url = '/browser/server/obj/' + try: + all_id = get_ids() + server_ids = all_id['sid'] + db_ids = all_id['did'] + if db_ids: + db_ids = all_id['did'][0] + role_ids = all_id['lrid'] + if role_ids: + role_ids = all_id['lrid'][0] + table_space_ids = all_id['tsid'] + if table_space_ids: + table_space_ids = all_id['tsid'][0] + for server_id in server_ids: + db_id = db_ids[int(server_id)] + tablespace_id = None + role_id = None + if table_space_ids: + tablespace_id = table_space_ids[int(server_id)][0] + if role_ids: + role_id = role_ids[int(server_id)] + if db_id: + # Delete database + tester.delete(db_url + str(SERVER_GROUP) + '/' + + str(server_id) + '/' + str(db_id), + follow_redirects=True) + if tablespace_id: + # Delete tablespace + tester.delete( + table_space_url + str(SERVER_GROUP) + '/' + + str(server_id) + '/' + str(tablespace_id), + follow_redirects=True) + if role_id: + # Delete role + tester.delete(role_url + str(SERVER_GROUP) + '/' + + str(server_id) + '/' + str(role_id), + follow_redirects=True) + # Delete server + tester.delete(server_url + str(server_id)) + except Exception: + pass + os.remove(pickle_path) + else: + pass