public inbox for [email protected]
help / color / mirror / Atom feedFrom: Navnath Gadakh <[email protected]>
To: Dave Page <[email protected]>
Cc: pgadmin-hackers <[email protected]>
Cc: Kanchan Mohitey <[email protected]>
Subject: pgAdmin IV : Unittest modular patch (Domains and Tables nodes)
Date: Tue, 30 Aug 2016 17:32:50 +0530
Message-ID: <CAOAJCYrxhfbsjCnTQt0r6DuwxGTBO1VzGvym-rWjnwxU5nqtOg@mail.gmail.com> (raw)
List-Unsubscribe: <mailto:[email protected]?body=unsub%20pgadmin-hackers>
Hi Dave,
Please find the patch API unit test cases for Domain & Tables Nodes.
This patch also includes code to drop the all objects(like database, roles,
tablespace & server) created during the test suite run.
*To run the test suite for domain node:*
python regression/runtests.py --pkg
browser.server_groups.servers.databases.schemas.domains
*To run the test suite for tables node:*
python regression/runtests.py --pkg
browser.server_groups.servers.databases.schemas.tables
*To run the test suite for all nodes *(Comment the all test code in
'synonyms' node i.e. Code under 'tests' directory as its partially
completed):
python regression/runtests.py
--
Thanks,
Navnath Gadakh
Software Engineer
EnterpriseDB Corporation
Mobile: +91 9975389878
--
Sent via pgadmin-hackers mailing list ([email protected])
To make changes to your subscription:
http://www.postgresql.org/mailpref/pgadmin-hackers
Attachments:
[application/octet-stream] domain_tables_apis.patch (80.5K, 3-domain_tables_apis.patch)
download | inline diff:
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
view thread (5+ messages) latest in thread
reply
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Reply to all the recipients using the --to and --cc options:
reply via email
To: [email protected]
Cc: [email protected], [email protected], [email protected]
Subject: Re: pgAdmin IV : Unittest modular patch (Domains and Tables nodes)
In-Reply-To: <CAOAJCYrxhfbsjCnTQt0r6DuwxGTBO1VzGvym-rWjnwxU5nqtOg@mail.gmail.com>
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
This inbox is served by agora; see mirroring instructions
for how to clone and mirror all data and code used for this inbox