diff --git a/web/pgadmin/browser/server_groups/servers/databases/languages/__init__.py b/web/pgadmin/browser/server_groups/servers/databases/languages/__init__.py index 341743c57..4abfb1d01 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/languages/__init__.py +++ b/web/pgadmin/browser/server_groups/servers/databases/languages/__init__.py @@ -306,6 +306,7 @@ class LanguageView(PGChildNodeView): """ sql = render_template("/".join([self.template_path, 'properties.sql']), lid=lid) + status, result = self.conn.execute_2darray(sql) if not status: return internal_server_error(errormsg=result) diff --git a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/language_testcases.json b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/language_testcases.json new file mode 100644 index 000000000..ca09ebbc0 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/language_testcases.json @@ -0,0 +1,317 @@ +{ + "create_language": [{ + "Test_case": "Language add test case", + "url": "/browser/language/obj/", + "is_positive": true, + "parameters_to_compare": [ + "name", + "lanowner", + "trusted", + "lanproc", + "laninl", + "lanval" + ], + "expected_data": { + "status_code": 200 + } + }, + { + "Test_case": "Missing required parameter while creating langauge", + "url": "/browser/language/obj/", + "is_positive": false, + "missing_name": true, + "expected_data": { + "status_code": 410, + "message": "Could not find the required parameter" + } + }, + + { + + "Test_case": "Error while crerating langauge with missing langauge pack", + "url": "/browser/language/obj/", + "is_positive": false, + "missing_lang_pack": true, + "expected_data": { + "status_code": 500, + "message": "Could not find the required parameter" + } + }, + { + + "Test_case": "Error while getting properties created langauge", + "url": "/browser/language/obj/", + "is_positive": false, + "error_in_properties": true, + "expected_data": { + "status_code": 500, + "message": "Error while getting properties created langauge." + } + } + ], + "get_language": [{ + "Test_case": "Language properties get test case", + "url": "/browser/language/obj/", + "is_positive": true, + "expected_data": { + "status_code": 200 + } + }, + { + "Test_case": "Language properties get test case using wrong id", + "url": "/browser/language/obj/", + "is_positive": false, + "invalid_id": true, + "expected_data": { + "status_code": 410, + "message": "Could not find the required language" + } + }, + { + "Test_case": "Error while getting created langauges properties", + "url": "/browser/language/obj/", + "is_positive": false, + "error_in_language_properties": true, + "expected_data": { + "status_code": 500, + "message": "Internal server error while getting langauges" + } + }, + { + "Test_case": "Error while getting created langauges acl", + "url": "/browser/language/obj/", + "is_positive": false, + "language_acl": true, + "expected_data": { + "status_code": 500, + "message": "Internal server error while getting langauges acl" + } + }, + { + + "Test_case": "Language list get test case", + "url": "/browser/language/obj/", + "is_positive": true, + "language_list": true, + "expected_data": { + "status_code": 200 + } + }, + { + "Test_case": "Error while getting created langauges list", + "url": "/browser/language/obj/", + "is_positive": false, + "language_list": true, + "expected_data": { + "status_code": 500, + "message": "Internal server error while getting langauges" + } + } + ], + "get_language_node": [{ + "Test_case": "Language get nodes test case", + "url": "/browser/language/nodes/", + "is_positive": true, + "expected_data": { + "status_code": 200 + } + }, + { + "Test_case": "Error while getting language nodes", + "url": "/browser/language/nodes/", + "is_positive": false, + "expected_data": { + "status_code": 500, + "message": "Could not find the required parameter" + } + }, + + { + "Test_case": "Single language get node test case", + "url": "/browser/language/nodes/", + "is_positive": true, + "language_node": true, + "expected_data": { + "status_code": 200 + } + }, + + { + "Test_case": "Error while getting single language node", + "url": "/browser/language/nodes/", + "language_node": true, + "is_positive": false, + "expected_data": { + "status_code": 500, + "message": "Could not find the required parameter" + } + } + + ], + "update_language": [{ + "Test_case": "Language update test case", + "url": "/browser/language/obj/", + "is_positive": true, + "expected_data": { + "status_code": 200 + } + }, + + { + "Test_case": "Error while updating the created language", + "url": "/browser/language/obj/", + "is_positive": false, + "error_in_update_language": true, + "dummy_dict": { + "rows": [{ + "oid": 34155, + "name": "language_4f726c8", + "trusted": true, + "acl": null, + "lanproc": "plpgsql_call_handler", + "lanval": null, + "description": null, + "lanowner": "postgres", + "laninl": null, + "seclabels": null + }] + }, + "expected_data": { + "status_code": 500, + "message": "Internal server error while updating properties" + } + + } + ], + "get_language_sql": [{ + "Test_case": "Language get sql test case", + "url": "/browser/language/sql/", + "is_positive": true, + "expected_data": { + "status_code": 200 + } + }, + + { + "Test_case": "Language get sql test case using wrong language id", + "url": "/browser/language/sql/", + "missing_paramter": true, + "is_positive": false, + "expected_data": { + "status_code": 410, + "message": "Could not find the required parameter" + } + }, + + { + "Test_case": "Error while getting language functions", + "url": "/browser/language/sql/", + "is_positive": false, + "expected_data": { + "status_code": 500, + "message": "Error while getting language sql" + } + + } + ], + "get_language_function_and_template": [{ + "Test_case": "Language get functions test case", + "url": "/browser/language/get_functions/", + "is_positive": true, + "expected_data": { + "status_code": 200 + } + }, + + { + "Test_case": "Language get templates test case", + "url": "/browser/language/get_templates/", + "is_positive": true, + "expected_data": { + "status_code": 200 + } + }, + + { + "Test_case": "Error while getting language functions", + "url": "/browser/language/get_functions/", + "is_positive": false, + "expected_data": { + "status_code": 500, + "message": "Error while getting language functions" + } + }, + + { + "Test_case": "Error while getting language template", + "url": "/browser/language/get_templates/", + "is_positive": false, + "expected_data": { + "status_code": 500, + "message": "Error while getting language templates" + } + + } + ], + "get_language_dependent": [{ + "Test_case": "Language get dependency test case", + "url": "/browser/language/dependent/", + "expected_data": { + "status_code": 200 + } + + }], + "get_language_dependency": [{ + "Test_case": "Language get dependency test case", + "url": "/browser/language/dependency/", + "expected_data": { + "status_code": 200 + } + + }], + "language_delete": [{ + "Test_case": "Language delete test case", + "url": "/browser/language/obj/", + "is_positive": true, + "expected_data": { + "status_code": 200 + } + }, + + + { + "Test_case": "Error while getting getting a language to delete", + "url": "/browser/language/obj/", + "is_positive": false, + "error_in_getting_language": true, + "expected_data": { + "status_code": 500, + "message": "Internal server error while deleting properties" + } + }, + + { + "Test_case": "Error while deleting the created langauge", + "url": "/browser/language/obj/", + "is_positive": false, + "error_in_deleting_language": true, + "expected_data": { + "status_code": 500, + "message": "Internal server error while deleting properties" + } + } + + ], + "delete_multiple": [{ + "Test_case": "Language delete test case", + "url": "/browser/language/obj/" + }, + + { + "Test_case": "Language delete test case", + "url": "/browser/language/obj/" + } + ] + + +} diff --git a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_add.py b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_add.py index ed285477a..0288934d9 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_add.py +++ b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_add.py @@ -11,6 +11,7 @@ from __future__ import print_function import json import uuid +import sys from pgadmin.browser.server_groups.servers.databases.tests import \ utils as database_utils @@ -19,15 +20,27 @@ from regression import parent_node_dict from regression.python_test_utils import test_utils as utils from . import utils as language_utils +if sys.version_info < (3, 3): + from mock import patch +else: + from unittest.mock import patch + class LanguagesAddTestCase(BaseTestGenerator): skip_on_database = ['gpdb'] - scenarios = [ - ('Language add test case', dict(url='/browser/language/obj/')) - ] + scenarios = language_utils.generate_scenarios('create_language') def setUp(self): super(LanguagesAddTestCase, self).setUp() + db_user = self.server['username'] + self.data = { + "name": "language_%s" % str(uuid.uuid4())[1:8], + "lanowner": db_user, + "trusted": True, + "lanproc": "plpgsql_call_handler", + "laninl": "btint2sortsupport", + "lanval": "fmgr_c_validator", + } self.server_data = parent_node_dict["database"][-1] self.server_id = self.server_data["server_id"] self.db_id = self.server_data['db_id'] @@ -42,41 +55,51 @@ class LanguagesAddTestCase(BaseTestGenerator): def runTest(self): """This function will add language under test database.""" - db_user = self.server['username'] + actual_status_code = '' + expected_status_code = '' + if self.is_positive: + response = self.create_language() + actual_status_code = response.status_code + expected_output = language_utils.verify_language(self) + expected_status_code = self.expected_data["status_code"] + self.assertDictEqual(expected_output, self.data) + else: + if hasattr(self, "missing_name"): + del self.data["name"] + response = self.create_language() + actual_status_code = response.status_code + expected_status_code = self.expected_data["status_code"] + if hasattr(self, "missing_lang_pack"): + self.data['name'] = 'plperlu' + response = self.create_language() + actual_status_code = response.status_code + expected_status_code = self.expected_data["status_code"] - self.data = { - "lanacl": [], - "laninl": "btint2sortsupport", - "lanowner": db_user, - "lanproc": "plpgsql_call_handler", - "lanval": "fmgr_c_validator", - "name": "language_%s" % str(uuid.uuid4())[1:8], - "seclabels": [], - "template_list": [ - "plperl", - "plperlu", - "plpython2u", - "plpython3u", - "plpythonu", - "pltcl", - "pltclu" - ], - "trusted": "true" - } + if hasattr(self, "error_in_properties"): + with patch( + 'pgadmin.utils.driver.psycopg2.connection.Connection' + '.execute_dict', + side_effect=[(True, True), ( + False, self.expected_data["message"])]): + response = self.create_language() + actual_status_code = response.status_code + expected_status_code = self.expected_data["status_code"] + self.assertEquals(actual_status_code, expected_status_code) - response = self.tester.post( + def create_language(self): + """This function will add language under test database.""" + return self.tester.post( self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + str(self.db_id) + '/', data=json.dumps(self.data), content_type='html/json') - self.assertEquals(response.status_code, 200) - def tearDown(self): """This function delete added language and disconnect the test database.""" - language_utils.delete_language( - self.server, self.db_name, self.data['name'] - ) - database_utils.disconnect_database(self, self.server_id, self.db_id) + if self.is_positive or hasattr(self, "error_in_properties"): + language_utils.delete_language( + self.server, self.db_name, self.data['name']) + database_utils.disconnect_database(self, self.server_id, + self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_delete.py b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_delete.py index 487595267..5b25ea166 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_delete.py +++ b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_delete.py @@ -8,9 +8,8 @@ ########################################################################## from __future__ import print_function - +import sys import uuid - from pgadmin.browser.server_groups.servers.databases.tests import \ utils as database_utils from pgadmin.utils.route import BaseTestGenerator @@ -18,11 +17,15 @@ from regression import parent_node_dict from regression.python_test_utils import test_utils as utils from . import utils as language_utils +if sys.version_info < (3, 3): + from mock import patch +else: + from unittest.mock import patch + class LanguagesDeleteTestCase(BaseTestGenerator): - scenarios = [ - ('Language delete test case', dict(url='/browser/language/obj/')) - ] + scenarios = language_utils.generate_scenarios( + 'language_delete') def setUp(self): self.server_data = parent_node_dict["database"][-1] @@ -42,12 +45,36 @@ class LanguagesDeleteTestCase(BaseTestGenerator): self.lang_name) def runTest(self): - """This function will delete language under test database.""" + """This function contains the test cases for delete language""" - response = self.tester.delete("{0}{1}/{2}/{3}/{4}".format( + if self.is_positive: + response = self.delete_language() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + elif hasattr(self, 'error_in_getting_language'): + with patch('pgadmin.utils.driver.psycopg2.connection.Connection' + '.execute_scalar', + return_value=(False, self.expected_data["message"])): + response = self.delete_language() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + + elif self.error_in_deleting_language: + with patch('pgadmin.utils.driver.psycopg2.connection.Connection' + '.execute_scalar', + side_effect=[(True, True), ( + False, self.expected_data["message"])]): + response = self.delete_language() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + + self.assertEquals(actual_response_code, expected_status_code) + + def delete_language(self): + """This function will delete language under test database.""" + return self.tester.delete("{0}{1}/{2}/{3}/{4}".format( self.url, utils.SERVER_GROUP, self.server_id, self.db_id, self.language_id), follow_redirects=True) - self.assertEquals(response.status_code, 200) def tearDown(self): """This function disconnect the test database.""" diff --git a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_delete_multiple.py b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_delete_multiple.py index 95f8574e8..02003908d 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_delete_multiple.py +++ b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_delete_multiple.py @@ -21,9 +21,7 @@ from . import utils as language_utils class LanguagesDeleteMultipleTestCase(BaseTestGenerator): - scenarios = [ - ('Language delete test case', dict(url='/browser/language/obj/')) - ] + scenarios = language_utils.generate_scenarios('delete_multiple') def setUp(self): self.server_data = parent_node_dict["database"][-1] diff --git a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_dependency.py b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_dependency.py new file mode 100644 index 000000000..e2bbc8c4e --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_dependency.py @@ -0,0 +1,65 @@ +########################################################################## +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2020, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +########################################################################## + +from __future__ import print_function + +import uuid + +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils +from pgadmin.utils.route import BaseTestGenerator +from regression import parent_node_dict +from regression.python_test_utils import test_utils as utils +from . import utils as language_utils + + +class LanguagesGetDependencyTestCase(BaseTestGenerator): + scenarios = language_utils.generate_scenarios( + 'get_language_dependency') + + def setUp(self): + self.server_data = parent_node_dict["database"][-1] + self.server_id = self.server_data["server_id"] + self.db_id = self.server_data['db_id'] + self.db_name = self.server_data["db_name"] + self.lang_name = "language_%s" % str(uuid.uuid4())[1:8] + db_con = database_utils.connect_database(self, + utils.SERVER_GROUP, + self.server_id, + self.db_id) + + if not db_con["info"] == "Database connected.": + raise Exception("Could not connect to database.") + self.language_id = language_utils.create_language(self.server, + self.db_name, + self.lang_name) + + def runTest(self): + """This function contains the test cases for language dependency""" + + response = self.get_language_dependency() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + self.assertEquals(actual_response_code, expected_status_code) + + def get_language_dependency(self): + """ + This function will get the language dependency + :return:language dependency response + """ + return self.tester.get("{0}{1}/{2}/{3}/{4}".format( + self.url, utils.SERVER_GROUP, self.server_id, self.db_id, + self.language_id), follow_redirects=True) + + def tearDown(self): + """This function delete added language and + disconnect the test database.""" + language_utils.delete_language(self.server, self.db_name, + self.lang_name) + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_dependent.py b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_dependent.py new file mode 100644 index 000000000..40db86748 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_dependent.py @@ -0,0 +1,64 @@ +########################################################################## +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2020, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +########################################################################## + +from __future__ import print_function + +import uuid +from regression import parent_node_dict +from . import utils as language_utils +from regression.python_test_utils import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils + + +class LanguagesGetDependencyTestCase(BaseTestGenerator): + scenarios = language_utils.generate_scenarios( + 'get_language_dependent') + + def setUp(self): + self.server_data = parent_node_dict["database"][-1] + self.server_id = self.server_data["server_id"] + self.db_id = self.server_data['db_id'] + self.db_name = self.server_data["db_name"] + self.lang_name = "language_%s" % str(uuid.uuid4())[1:8] + db_con = database_utils.connect_database(self, + utils.SERVER_GROUP, + self.server_id, + self.db_id) + + if not db_con["info"] == "Database connected.": + raise Exception("Could not connect to database.") + self.language_id = language_utils.create_language(self.server, + self.db_name, + self.lang_name) + + def runTest(self): + """This function contains the test cases for language dependent""" + + response = self.get_language_dependency() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + self.assertEquals(actual_response_code, expected_status_code) + + def get_language_dependency(self): + """ + This function will get the language dependency + :return:language dependency response + """ + return self.tester.get("{0}{1}/{2}/{3}/{4}".format( + self.url, utils.SERVER_GROUP, self.server_id, self.db_id, + self.language_id), follow_redirects=True) + + def tearDown(self): + """This function delete added language and + disconnect the test database.""" + language_utils.delete_language(self.server, self.db_name, + self.lang_name) + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_get.py b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_get.py index f6a70c01d..0eed51fc6 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_get.py +++ b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_get.py @@ -10,7 +10,7 @@ from __future__ import print_function import uuid - +import sys from pgadmin.browser.server_groups.servers.databases.tests import \ utils as database_utils from pgadmin.utils.route import BaseTestGenerator @@ -18,11 +18,104 @@ from regression import parent_node_dict from regression.python_test_utils import test_utils as utils from . import utils as language_utils +if sys.version_info < (3, 3): + from mock import patch +else: + from unittest.mock import patch + class LanguagesGetTestCase(BaseTestGenerator): - scenarios = [ - ('Language get test case', dict(url='/browser/language/obj/')) - ] + scenarios = language_utils.generate_scenarios('get_language') + + def setUp(self): + self.server_data = parent_node_dict["database"][-1] + self.server_id = self.server_data["server_id"] + self.db_id = self.server_data['db_id'] + self.db_name = self.server_data["db_name"] + self.lang_name = "language_%s" % str(uuid.uuid4())[1:8] + db_con = database_utils.connect_database(self, + utils.SERVER_GROUP, + self.server_id, + self.db_id) + + if not db_con["info"] == "Database connected.": + raise Exception("Could not connect to database.") + if self.is_positive: + self.language_id = language_utils.create_language(self.server, + self.db_name, + self.lang_name) + + def runTest(self): + """This function contains the test cases for language get""" + + actual_response_code = '' + expected_status_code = 'none' + if self.is_positive: + if hasattr(self, 'language_list'): + response = self.get_language_list() + else: + response = self.get_language_properties() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + else: + if hasattr(self, 'invalid_id'): + self.language_id = 9999 + response = self.get_language_properties() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + + elif hasattr(self, 'language_list') or \ + hasattr(self, 'error_in_language_properties'): + with patch( + 'pgadmin.utils.driver.psycopg2.connection.Connection' + '.execute_dict', + return_value=(False, + self.expected_data["message"])): + + if hasattr(self, 'language_list'): + response = self.get_language_list() + + elif hasattr(self, 'error_in_language_properties'): + self.language_id = 9999 + response = self.get_language_properties() + + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + elif self.language_acl: + dummy_dict = {"rows": {"data1": "1", "data2": "2"}} + with patch( + 'pgadmin.utils.driver.psycopg2.connection.Connection' + '.execute_dict', + side_effect=[(True, dummy_dict), ( + False, self.expected_data["message"])]): + self.language_id = 9999 + response = self.get_language_properties() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + + self.assertEquals(actual_response_code, expected_status_code) + + def get_language_properties(self): + return self.tester.get("{0}{1}/{2}/{3}/{4}".format( + self.url, utils.SERVER_GROUP, self.server_id, self.db_id, + self.language_id), follow_redirects=True) + + def get_language_list(self): + return self.tester.get("{0}{1}/{2}/{3}/".format( + self.url, utils.SERVER_GROUP, self.server_id, self.db_id), + follow_redirects=True) + + def tearDown(self): + """This function delete added language and + disconnect the test database.""" + if self.is_positive: + language_utils.delete_language(self.server, self.db_name, + self.lang_name) + database_utils.disconnect_database(self, self.server_id, self.db_id) + + +class LanguagesGetNodesTestCase(BaseTestGenerator): + scenarios = language_utils.generate_scenarios('get_language_node') def setUp(self): self.server_data = parent_node_dict["database"][-1] @@ -44,15 +137,41 @@ class LanguagesGetTestCase(BaseTestGenerator): def runTest(self): """This function will get the language under test database.""" - response = self.tester.get("{0}{1}/{2}/{3}/{4}".format( + if self.is_positive: + if hasattr(self, 'language_node'): + response = self.get_language_node() + else: + response = self.get_language_nodes() + + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + else: + with patch('pgadmin.utils.driver.psycopg2.connection.Connection' + '.execute_2darray', + return_value=(False, + self.expected_data["message"])): + if hasattr(self, 'language_node'): + response = self.get_language_node() + else: + response = self.get_language_nodes() + + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + self.assertEquals(actual_response_code, expected_status_code) + + def get_language_nodes(self): + return self.tester.get("{0}{1}/{2}/{3}/".format( + self.url, utils.SERVER_GROUP, self.server_id, self.db_id), + follow_redirects=True) + + def get_language_node(self): + return self.tester.get("{0}{1}/{2}/{3}/{4}".format( self.url, utils.SERVER_GROUP, self.server_id, self.db_id, self.language_id), follow_redirects=True) - self.assertEquals(response.status_code, 200) def tearDown(self): """This function delete added language and disconnect the test database.""" - language_utils.delete_language(self.server, self.db_name, self.lang_name) database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_get_function_and_template.py b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_get_function_and_template.py new file mode 100644 index 000000000..ab0e968ab --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_get_function_and_template.py @@ -0,0 +1,78 @@ +########################################################################## +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2020, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +########################################################################## + +from __future__ import print_function + +import uuid +import sys +from . import utils as language_utils +from regression.python_test_utils import test_utils as utils +from regression import parent_node_dict +from pgadmin.utils.route import BaseTestGenerator +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils + +if sys.version_info < (3, 3): + from mock import patch +else: + from unittest.mock import patch + + +class LanguagesGetFunctionAndTemplateTestCase(BaseTestGenerator): + scenarios = language_utils.generate_scenarios( + 'get_language_function_and_template') + + def setUp(self): + self.server_data = parent_node_dict["database"][-1] + self.server_id = self.server_data["server_id"] + self.db_id = self.server_data['db_id'] + self.db_name = self.server_data["db_name"] + self.lang_name = "language_%s" % str(uuid.uuid4())[1:8] + db_con = database_utils.connect_database(self, + utils.SERVER_GROUP, + self.server_id, + self.db_id) + + if not db_con["info"] == "Database connected.": + raise Exception("Could not connect to database.") + self.language_id = language_utils.create_language(self.server, + self.db_name, + self.lang_name) + + def runTest(self): + """This function will get the language under test database.""" + if self.is_positive: + response = self.get_language_functions_template() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + else: + with patch('pgadmin.utils.driver.psycopg2.connection.Connection' + '.execute_dict', + return_value=(False, + self.expected_data["message"])): + response = self.get_language_functions_template() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + self.assertEquals(actual_response_code, expected_status_code) + + def get_language_functions_template(self): + """ + This function will get the language function + :return:language function response + """ + return self.tester.get("{0}{1}/{2}/{3}/".format( + self.url, utils.SERVER_GROUP, self.server_id, self.db_id), + follow_redirects=True) + + def tearDown(self): + """This function delete added language and + disconnect the test database.""" + language_utils.delete_language(self.server, self.db_name, + self.lang_name) + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_put.py b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_put.py index babf00a80..2c978117f 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_put.py +++ b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_put.py @@ -11,19 +11,22 @@ from __future__ import print_function import json import uuid - +import sys +from regression.python_test_utils import test_utils as utils +from pgadmin.utils.route import BaseTestGenerator from pgadmin.browser.server_groups.servers.databases.tests import \ utils as database_utils -from pgadmin.utils.route import BaseTestGenerator from regression import parent_node_dict -from regression.python_test_utils import test_utils as utils from . import utils as language_utils +if sys.version_info < (3, 3): + from mock import patch +else: + from unittest.mock import patch + class LanguagesPutTestCase(BaseTestGenerator): - scenarios = [ - ('Language update test case', dict(url='/browser/language/obj/')) - ] + scenarios = language_utils.generate_scenarios('update_language') def setUp(self): self.server_data = parent_node_dict["database"][-1] @@ -44,16 +47,33 @@ class LanguagesPutTestCase(BaseTestGenerator): def runTest(self): """This function will update the language under test database.""" + if self.is_positive: + response = self.update_language() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + + elif self.error_in_update_language: + + with patch('pgadmin.utils.driver.psycopg2.connection.Connection' + '.execute_dict', + side_effect=[(True, self.dummy_dict), ( + False, self.expected_data["message"])]): + response = self.update_language() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + + self.assertEquals(actual_response_code, expected_status_code) + + def update_language(self): data = \ { "id": self.language_id, "description": "This is test comment." } - response = self.tester.put("{0}{1}/{2}/{3}/{4}".format( + return self.tester.put("{0}{1}/{2}/{3}/{4}".format( self.url, utils.SERVER_GROUP, self.server_id, self.db_id, self.language_id), data=json.dumps(data), follow_redirects=True) - self.assertEquals(response.status_code, 200) def tearDown(self): """This function delete added language and diff --git a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_sql.py b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_sql.py new file mode 100644 index 000000000..639cf2f86 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/test_language_sql.py @@ -0,0 +1,84 @@ +########################################################################## +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2020, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +########################################################################## + +from __future__ import print_function + +import uuid +import sys +from pgadmin.utils.route import BaseTestGenerator +from regression import parent_node_dict +from . import utils as language_utils +from regression.python_test_utils import test_utils as utils +from pgadmin.browser.server_groups.servers.databases.tests import \ + utils as database_utils + +if sys.version_info < (3, 3): + from mock import patch +else: + from unittest.mock import patch + + +class LanguagesGetFunctionAndTemplateTestCase(BaseTestGenerator): + scenarios = language_utils.generate_scenarios('get_language_sql') + + def setUp(self): + self.server_data = parent_node_dict["database"][-1] + self.server_id = self.server_data["server_id"] + self.db_id = self.server_data['db_id'] + self.db_name = self.server_data["db_name"] + self.lang_name = "language_%s" % str(uuid.uuid4())[1:8] + db_con = database_utils.connect_database(self, + utils.SERVER_GROUP, + self.server_id, + self.db_id) + + if not db_con["info"] == "Database connected.": + raise Exception("Could not connect to database.") + self.language_id = language_utils.create_language(self.server, + self.db_name, + self.lang_name) + + def runTest(self): + """This function contains the test cases for language sql""" + if self.is_positive: + response = self.get_language_sql() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + elif hasattr(self, 'missing_paramter'): + self.language_id = 888888 + response = self.get_language_sql() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + else: + with patch('pgadmin.utils.driver.psycopg2.connection.Connection' + '.execute_dict', + return_value=(False, + self.expected_data[ + "message"])): + response = self.get_language_sql() + actual_response_code = response.status_code + expected_status_code = self.expected_data['status_code'] + self.assertEquals(actual_response_code, expected_status_code) + + def get_language_sql(self): + """ + This function will get the language function + :return:language function response + """ + return self.tester.get("{0}{1}/{2}/{3}/{4}".format( + self.url, utils.SERVER_GROUP, self.server_id, self.db_id, + self.language_id), + follow_redirects=True) + + def tearDown(self): + """This function delete added language and + disconnect the test database.""" + language_utils.delete_language(self.server, self.db_name, + self.lang_name) + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/utils.py index 660d2750c..cf23a726a 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/languages/tests/utils.py +++ b/web/pgadmin/browser/server_groups/servers/databases/languages/tests/utils.py @@ -11,9 +11,32 @@ from __future__ import print_function import sys import traceback - +import os +import json from regression.python_test_utils.test_utils import get_db_connection +CURRENT_PATH = os.path.dirname(os.path.realpath(__file__)) +with open(CURRENT_PATH + "/language_testcases.json") as data_file: + test_cases = json.load(data_file) + + +def generate_scenarios(key): + """ + This function generates the test case scenarios according to key given + to it, e.g. key=ADD, key=update etc. + :param key: for which operation generate the test scenario + :type key: str + :return: scenarios + :rtype: list + """ + scenarios = [] + for scenario in test_cases[key]: + test_name = scenario["Test_case"] + scenario.pop("Test_case") + tup = (test_name, dict(scenario)) + scenarios.append(tup) + return scenarios + def create_language(server, db_name, lang_name): """ @@ -51,31 +74,39 @@ def create_language(server, db_name, lang_name): traceback.print_exc(file=sys.stderr) -def verify_language(server, db_name, lang_name): +def verify_language(self): """ This function verifies the language exist in database or not. - :param server: server details - :type server: dict - :param db_name: database name - :type db_name: str - :param lang_name: language name - :type lang_name: str - :return language: language record - :rtype: tuple """ try: - connection = get_db_connection(db_name, - server['username'], - server['db_password'], - server['host'], - server['port'], - server['sslmode']) + connection = get_db_connection(self.db_name, + self.server['username'], + self.server['db_password'], + self.server['host'], + self.server['port'], + self.server['sslmode']) pg_cursor = connection.cursor() - pg_cursor.execute("SELECT oid from pg_language where lanname='%s'" % - lang_name) + pg_cursor.execute("SELECT * from pg_language where lanname='%s'" % + self.data["name"]) + pg_cursor.execute("select pl.lanname, " + "(select rolname from pg_authid where oid " + "= pl.lanowner) as lanowner, " + "pl.lanpltrusted, " + "( select prosrc from pg_proc where " + "oid = pl.lanplcallfoid) as lanplcallfoid, " + "( select prosrc from pg_proc where oid = " + "pl.laninline) as laninline, " + "( select prosrc from pg_proc where oid = " + "pl.lanvalidator) as lanvalidator " + "from pg_language pl where lanname='%s'" % + self.data["name"]) language = pg_cursor.fetchall() + expected_output = make_dict(self.parameters_to_compare, + list(language[0])) + connection.close() - return language + + return expected_output except Exception: traceback.print_exc(file=sys.stderr) @@ -111,3 +142,14 @@ def delete_language(server, db_name, lang_name): connection.close() except Exception: traceback.print_exc(file=sys.stderr) + + +def make_dict(paramaters, actual_data): + expected_output = {} + + for key in paramaters: + for value in actual_data: + expected_output[key] = value + actual_data.remove(value) + break + return expected_output diff --git a/web/regression/.coveragerc.in b/web/regression/.coveragerc.in index 40ced5ded..8ded7b2e0 100644 --- a/web/regression/.coveragerc.in +++ b/web/regression/.coveragerc.in @@ -12,7 +12,11 @@ source = omit = */tests/* */feature_tests/* - +# Here exclude the lines from the code +[report] +exclude_lines= + import* + except* # Mention patterns in 'include' to include code for the coverage measurement # Here, code coverage will show report only for modules mentioned in the # 'include'