diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/collations_test_data.json b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/collations_test_data.json new file mode 100644 index 000000000..187d72e7e --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/collations_test_data.json @@ -0,0 +1,415 @@ +{ + "create_collation": [ + { + "name": "Create collation: With valid data", + "url": "/browser/collation/obj/", + "is_positive_test": true, + "test_data": { + "copy_collation": "PLACE_HOLDER", + "name": "PLACE_HOLDER", + "owner": "PLACE_HOLDER", + "schema": "PLACE_HOLDER" + }, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 200 + } + }, + { + "name": "Create collation: With invalid data - Missing Parameter.", + "url": "/browser/collation/obj/", + "is_positive_test": false, + "parameter_missing": true, + "test_data": { + "copy_collation": "PLACE_HOLDER", + "name": "PLACE_HOLDER", + "owner": "PLACE_HOLDER", + "schema": "PLACE_HOLDER" + }, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 410, + "error_msg": "Could not find the required parameter (name)." + } + }, + { + "name": "Create collation: With invalid data - Incomplete Definition.", + "url": "/browser/collation/obj/", + "is_positive_test": false, + "error_incomplete_definition": true, + "test_data": { + "copy_collation": "PLACE_HOLDER", + "name": "PLACE_HOLDER", + "owner": "PLACE_HOLDER", + "schema": "PLACE_HOLDER" + }, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 410 + } + }, + { + "name": "Error while getting oid of newly created collation", + "url": "/browser/collation/obj/", + "error_getting_collation_oid": true, + "is_positive_test": false, + "test_data": { + "copy_collation": "PLACE_HOLDER", + "name": "PLACE_HOLDER", + "owner": "PLACE_HOLDER", + "schema": "PLACE_HOLDER" + + }, + "mocking_required": true, + "mock_data": { + "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_scalar", + "return_value": "(True, True), (False, 'Mocked Internal Server Error while getting oid of created collation')" + }, + "expected_data": { + "status_code": 500 + } + }, + { + "name": "Error while creating a collation - res - Internal server error", + "url": "/browser/collation/obj/", + "internal_server_error": true, + "is_positive_test": false, + "test_data": { + "copy_collation": "PLACE_HOLDER", + "name": "PLACE_HOLDER", + "owner": "PLACE_HOLDER", + "schema": "PLACE_HOLDER" + }, + "mocking_required": true, + "mock_data": { + "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_scalar", + "return_value": "(False, 'Mocked Internal Server Error')" + }, + "expected_data": { + "status_code": 500 + } + } + ], + "get_collation": [ + { + "name": "Get Collation", + "url": "/browser/collation/obj/", + "is_positive_test": true, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 200 + } + }, + { + "name": "Error while fetching a Collation", + "url": "/browser/collation/obj/", + "error_fetching_collation": true, + "is_positive_test": false, + "mocking_required": true, + "mock_data": { + "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict", + "return_value": "(False, 'Mocked Internal Server Error while fetching a collation')" + }, + "expected_data": { + "status_code": 500 + } + }, + { + "name": "Fetch collation using wrong collation id", + "url": "/browser/collation/obj/", + "wrong_collation_id": true, + "is_positive_test": false, + "mocking_required": false, + "mock_data": { + }, + "expected_data": { + "status_code": 410 + } + }, + { + "name": "Get Collation list", + "url": "/browser/collation/obj/", + "is_positive_test": true, + "collation_list": true, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 200 + } + }, + { + "name": "Error while fetching Collation list", + "url": "/browser/collation/obj/", + "error_fetching_collation": true, + "is_positive_test": false, + "collation_list": true, + "mocking_required": true, + "mock_data": { + "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict", + "return_value": "(False, 'Mocked Internal Server Error while fetching a collation')" + }, + "expected_data": { + "status_code": 500 + } + } + ], + "delete_collation": [ + { + "name": "delete Collation", + "url": "/browser/collation/obj/", + "is_positive_test": true, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 200 + } + }, + { + "name": "Error while deleting a Collation", + "url": "/browser/collation/obj/", + "error_deleting_collation": true, + "is_positive_test": false, + "mocking_required": true, + "mock_data": { + "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict", + "return_value": "(False, 'Mocked Internal Server Error while deleting a collation')" + }, + "expected_data": { + "status_code": 500 + } + }, + { + "name": "delete collation using wrong collation id", + "url": "/browser/collation/obj/", + "wrong_collation_id": true, + "is_positive_test": false, + "mocking_required": false, + "mock_data": { + }, + "expected_data": { + "status_code": 410 + } + }, + { + "name": "Error while deleting a created Collation", + "url": "/browser/collation/obj/", + "error_deleting_created_collation": true, + "is_positive_test": false, + "mocking_required": true, + "mock_data": { + "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_scalar", + "return_value": "(False, 'Mocked Internal Server Error while deleting a collation')" + }, + "expected_data": { + "status_code": 500 + } + } + ], + "update_collation": [ + { + "name": "Update Collation", + "url": "/browser/collation/obj/", + "is_positive_test": true, + "mocking_required": false, + "test_data": { + "description": "This is collation update comment", + "id": "PLACE_HOLDER" + }, + "mock_data": {}, + "expected_data": { + "status_code": 200 + } + }, + { + "name": "Error while updating a Collation", + "url": "/browser/collation/obj/", + "error_updating_collation": true, + "test_data": { + "description": "This is collation update comment", + "id": "PLACE_HOLDER" + }, + "is_positive_test": false, + "mocking_required": true, + "mock_data": { + "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_scalar", + "return_value": "(False, 'Mocked Internal Server Error while fetching a collation')" + }, + "expected_data": { + "status_code": 500 + } + }, + { + "name": "Error while updating a Collation", + "url": "/browser/collation/obj/", + "internal_server_error": true, + "is_positive_test": false, + "test_data": { + "description": "This is collation update comment", + "id": "PLACE_HOLDER" + }, + "mocking_required": true, + "mock_data": { + "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray", + "return_value": "(False, 'Mocked Internal Server Error while fetching a collation')" + }, + "expected_data": { + "status_code": 500 + } + } + ], + "dependency_dependent_collation": [ + { + "name": "Get Collation dependency", + "url": "/browser/collation/dependency/", + "is_positive_test": true, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 200 + } + }, + { + "name": "Get Collation dependent", + "url": "/browser/collation/dependent/", + "is_positive_test": true, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 200 + } + } + ], + "get_collation_nodes_and_node": [ + { + "name": "Get Collation nodes", + "url": "/browser/collation/nodes/", + "is_positive_test": true, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 200 + } + }, + { + "name": "Error while fetching Collation nodes", + "url": "/browser/collation/nodes/", + "error_fetching_collation": true, + "is_positive_test": false, + "mocking_required": true, + "mock_data": { + "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray", + "return_value": "(False, 'Mocked Internal Server Error while fetching collation nodes')" + }, + "expected_data": { + "status_code": 500 + } + }, + { + "name": "Get Collation node", + "url": "/browser/collation/nodes/", + "is_positive_test": true, + "node": true, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 200 + } + }, + { + "name": "Error while fetching Collation node", + "url": "/browser/collation/nodes/", + "error_fetching_collation": true, + "is_positive_test": false, + "node": true, + "mocking_required": true, + "mock_data": { + "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray", + "return_value": "(False, 'Mocked Internal Server Error while fetching collation nodes')" + }, + "expected_data": { + "status_code": 500 + } + } + ], + "get_collation_func": [ + { + "name": "Get get_collation", + "url": "/browser/collation/get_collations/", + "is_positive_test": true, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 200 + } + }, + { + "name": "Error while fetching collations: With valid data while server down", + "url": "/browser/collation/get_collations/", + "is_positive_test": false, + "mocking_required": true, + "mock_data": { + "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_2darray", + "return_value": "(False, 'Mocked Internal Server Error while fetching collations')" + }, + "expected_data": { + "status_code": 500 + } + } + ], + "delete_multiple_collation" :[ + { + "name": "Delete multiple Collation", + "url": "/browser/collation/obj/", + "is_positive_test": true, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 200 + } + } + ], + "get_collation_sql": [ + { + "name": "Get Collation SQL", + "url": "/browser/collation/sql/", + "is_positive_test": true, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 200 + } + }, + { + "name": "Error while fetching a created Collation sql", + "url": "/browser/collation/sql/", + "error_fetching_collation": true, + "is_positive_test": false, + "mocking_required": true, + "mock_data": { + "function_name": "pgadmin.utils.driver.psycopg2.connection.Connection.execute_dict", + "return_value": "(False, 'Mocked Internal Server Error while fetching a collation sql')" + }, + "expected_data": { + "status_code": 500 + } + }, + { + "name": "Get collation msql: With existing collation id.", + "url": "/browser/collation/msql/", + "is_positive_test": true, + "msql": true, + "mocking_required": false, + "mock_data": {}, + "expected_data": { + "status_code": 200, + "error_msg": null, + "test_result_data": {} + }, + "is_list": false + } + ] +} diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_add.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_add.py index 68616b10d..925e3517c 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_add.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_add.py @@ -17,20 +17,26 @@ from pgadmin.browser.server_groups.servers.databases.tests import utils as \ 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 collation_utils +from unittest.mock import patch class CollationAddTestCase(BaseTestGenerator): """ This class will add new collation under schema node. """ skip_on_database = ['gpdb'] - scenarios = [ - # Fetching default URL for collation node. - ('Default Node URL', dict(url='/browser/collation/obj/')) - ] + scenarios = utils.generate_scenarios('create_collation', + collation_utils.test_cases) def setUp(self): super(CollationAddTestCase, self).setUp() self.database_info = parent_node_dict["database"][-1] self.db_name = self.database_info["db_name"] + self.schema_info = parent_node_dict["schema"][-1] + self.schema_name = self.schema_info["schema_name"] + self.schema_id = self.schema_info["schema_id"] + self.server_id = self.schema_info["server_id"] + self.db_id = self.schema_info["db_id"] + # Change the db name, so that schema will create in newly created db self.schema_name = "schema_get_%s" % str(uuid.uuid4())[1:8] connection = utils.get_db_connection(self.db_name, @@ -42,37 +48,63 @@ class CollationAddTestCase(BaseTestGenerator): self.schema_details = schema_utils.create_schema(connection, self.schema_name) + def create_collation(self): + """ + This function create a collation and returns the created collation + response + :return: created collation response + """ + return self.tester.post( + self.url + str(utils.SERVER_GROUP) + '/' + + str(self.server_id) + '/' + str(self.db_id) + '/' + + str(self.schema_id) + '/', + data=json.dumps(self.test_data), + content_type='html/json') + def runTest(self): """ This function will add collation under schema node. """ - schema_info = parent_node_dict["schema"][-1] - server_id = schema_info["server_id"] - db_id = schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, - server_id, db_id) + self.server_id, self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database to add collation.") - schema_id = self.schema_details[0] - schema_name = self.schema_details[1] + schema_response = schema_utils.verify_schemas(self.server, self.db_name, - schema_name) + self.schema_name) if not schema_response: raise Exception("Could not find the schema to add the collation.") - data = { - "copy_collation": "pg_catalog.\"C\"", - "name": "collation_add_%s" % str(uuid.uuid4())[1:8], - "owner": self.server["username"], - "schema": schema_name - } - response = self.tester.post(self.url + str(utils.SERVER_GROUP) + '/' + - str(server_id) + '/' + str(db_id) + '/' + - str(schema_id) + '/', - data=json.dumps(data), - content_type='html/json') - self.assertEquals(response.status_code, 200) - # Disconnect the database - database_utils.disconnect_database(self, server_id, db_id) + self.test_data['copy_collation'] = "pg_catalog.\"C\"" + self.test_data['name'] = "collation_add_%s" % str(uuid.uuid4())[1:8] + self.test_data['owner'] = self.server["username"] + self.test_data['schema'] = self.schema_name + + if self.is_positive_test: + response = self.create_collation() + else: + if hasattr(self, "parameter_missing"): + del self.test_data['name'] + response = self.create_collation() + + if hasattr(self, "error_incomplete_definition"): + del self.test_data['copy_collation'] + response = self.create_collation() + + if hasattr(self, "error_getting_collation_oid"): + with patch(self.mock_data["function_name"], + side_effect=eval(self.mock_data["return_value"])): + response = self.create_collation() + + if hasattr(self, "internal_server_error"): + return_value_object = eval(self.mock_data["return_value"]) + with patch(self.mock_data["function_name"], + side_effect=[return_value_object]): + response = self.create_collation() + + actual_response_code = response.status_code + expected_response_code = self.expected_data['status_code'] + self.assertEquals(actual_response_code, expected_response_code) def tearDown(self): - pass + # Disconnect the database + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_delete.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_delete.py index 57db8a323..2eb41d920 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_delete.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_delete.py @@ -17,35 +17,48 @@ 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 collation_utils +from unittest.mock import patch class CollationDeleteTestCase(BaseTestGenerator): """ This class will delete added collation under schema node. """ skip_on_database = ['gpdb'] - scenarios = [ - # Fetching default URL for collation node. - ('Fetch collation Node URL', dict(url='/browser/collation/obj/')) - ] + scenarios = utils.generate_scenarios('delete_collation', + collation_utils.test_cases) def setUp(self): super(CollationDeleteTestCase, self).setUp() self.schema_info = parent_node_dict["schema"][-1] + self.server_id = self.schema_info["server_id"] + self.db_id = self.schema_info["db_id"] self.schema_name = self.schema_info["schema_name"] + self.schema_id = self.schema_info["schema_id"] self.db_name = parent_node_dict["database"][-1]["db_name"] - coll_name = "collation_get_%s" % str(uuid.uuid4())[1:8] + self.coll_name = "collation_get_%s" % str(uuid.uuid4())[1:8] self.collation = collation_utils.create_collation(self.server, self.schema_name, - coll_name, + self.coll_name, self.db_name) + self.collation_id = self.collation[0] + + def delete_collation(self): + """ + This function returns the collation delete response + :return: collation delete response + """ + return self.tester.delete( + self.url + str(utils.SERVER_GROUP) + '/' + str( + self.server_id) + '/' + + str(self.db_id) + '/' + str(self.schema_id) + '/' + + str(self.collation_id), + content_type='html/json') def runTest(self): """ This function will delete collation under schema node. """ - server_id = self.schema_info["server_id"] - db_id = self.schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, - server_id, - db_id) + self.server_id, + self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") @@ -54,16 +67,30 @@ class CollationDeleteTestCase(BaseTestGenerator): self.schema_name) if not schema_response: raise Exception("Could not find the schema.") - collation_id = self.collation[0] - schema_id = self.schema_info["schema_id"] - get_response = self.tester.delete( - self.url + str(utils.SERVER_GROUP) + '/' + str( - server_id) + '/' + - str(db_id) + '/' + str(schema_id) + '/' + str(collation_id), - content_type='html/json') - self.assertEquals(get_response.status_code, 200) - # Disconnect database to delete it - database_utils.disconnect_database(self, server_id, db_id) + + if self.is_positive_test: + response = self.delete_collation() + + else: + if hasattr(self, "error_deleting_collation"): + with patch(self.mock_data["function_name"], + return_value=eval(self.mock_data["return_value"])): + response = self.delete_collation() + + if hasattr(self, "error_deleting_created_collation"): + return_value_object = eval(self.mock_data["return_value"]) + with patch(self.mock_data["function_name"], + side_effect=[return_value_object]): + response = self.delete_collation() + + if hasattr(self, "wrong_collation_id"): + self.collation_id = 99999 + response = self.delete_collation() + + actual_response_code = response.status_code + expected_response_code = self.expected_data['status_code'] + self.assertEquals(actual_response_code, expected_response_code) def tearDown(self): - pass + # Disconnect database to delete it + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_delete_multiple.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_delete_multiple.py index 310a8e437..610159654 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_delete_multiple.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_delete_multiple.py @@ -23,10 +23,8 @@ from . import utils as collation_utils class CollationDeleteMultipleTestCase(BaseTestGenerator): """ This class will delete added collations under schema node. """ skip_on_database = ['gpdb'] - scenarios = [ - # Fetching default URL for collation node. - ('Fetch collation Node URL', dict(url='/browser/collation/obj/')) - ] + scenarios = utils.generate_scenarios('delete_multiple_collation', + collation_utils.test_cases) def setUp(self): super(CollationDeleteMultipleTestCase, self).setUp() @@ -46,14 +44,29 @@ class CollationDeleteMultipleTestCase(BaseTestGenerator): self.db_name) ] + def delete_multiple(self, data): + """ + This function returns multiple collation delete response + :param data: collation ids to delete + :return: collation delete response + """ + return self.tester.delete( + self.url + str(utils.SERVER_GROUP) + '/' + str( + self.server_id) + '/' + + str(self.db_id) + '/' + str(self.schema_id) + '/', + content_type='html/json', + data=json.dumps(data), + follow_redirects=True, + ) + def runTest(self): """ This function will delete collations under schema node. """ - server_id = self.schema_info["server_id"] - db_id = self.schema_info["db_id"] + self.server_id = self.schema_info["server_id"] + self.db_id = self.schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, - server_id, - db_id) + self.server_id, + self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") @@ -63,18 +76,15 @@ class CollationDeleteMultipleTestCase(BaseTestGenerator): if not schema_response: raise Exception("Could not find the schema.") data = {'ids': [self.collations[0][0], self.collations[1][0]]} - schema_id = self.schema_info["schema_id"] - get_response = self.tester.delete( - self.url + str(utils.SERVER_GROUP) + '/' + str( - server_id) + '/' + - str(db_id) + '/' + str(schema_id) + '/', - content_type='html/json', - data=json.dumps(data), - follow_redirects=True, - ) - self.assertEquals(get_response.status_code, 200) - # Disconnect database to delete it - database_utils.disconnect_database(self, server_id, db_id) + self.schema_id = self.schema_info["schema_id"] + + if self.is_positive_test: + response = self.delete_multiple(data) + + actual_response_code = response.status_code + expected_response_code = self.expected_data['status_code'] + self.assertEquals(actual_response_code, expected_response_code) def tearDown(self): - pass + # Disconnect database to delete it + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_dependency_dependent.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_dependency_dependent.py new file mode 100644 index 000000000..cd6c6f482 --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_dependency_dependent.py @@ -0,0 +1,77 @@ +########################################################################## +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2020, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +########################################################################## + +import json +import uuid + +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.utils.route import BaseTestGenerator +from regression import parent_node_dict +from regression.python_test_utils import test_utils as utils +from . import utils as collation_utils + + +class CollationDependentsTestCase(BaseTestGenerator): + """ This class will add new collation under schema node. """ + skip_on_database = ['gpdb'] + scenarios = utils.generate_scenarios('dependency_dependent_collation', + collation_utils.test_cases) + + def setUp(self): + super(CollationDependentsTestCase, self).setUp() + self.schema_info = parent_node_dict["schema"][-1] + self.schema_name = self.schema_info["schema_name"] + self.schema_id = self.schema_info["schema_id"] + self.db_name = parent_node_dict["database"][-1]["db_name"] + self.server_id = self.schema_info["server_id"] + self.db_id = self.schema_info["db_id"] + coll_name = "collation_get_%s" % str(uuid.uuid4())[1:8] + self.collation = collation_utils.create_collation(self.server, + self.schema_name, + coll_name, + self.db_name) + + def get_dependency_dependent(self): + """ + This function returns the collation dependency and dependent + :return: collation dependency and dependent + """ + return self.tester.get( + self.url + str(utils.SERVER_GROUP) + '/' + + str(self.server_id) + '/' + + str(self.db_id) + '/' + str(self.schema_id) + '/' + + str(self.collation_id), + content_type='html/json') + + def runTest(self): + """ This function will add collation under schema node. """ + db_con = database_utils.connect_database(self, utils.SERVER_GROUP, + self.server_id, self.db_id) + if not db_con['data']["connected"]: + raise Exception("Could not connect to database.") + schema_response = schema_utils.verify_schemas(self.server, + self.db_name, + self.schema_name) + if not schema_response: + raise Exception("Could not find the schema.") + self.collation_id = self.collation[0] + + if self.is_positive_test: + response = self.get_dependency_dependent() + + actual_response_code = response.status_code + expected_response_code = self.expected_data['status_code'] + self.assertEquals(actual_response_code, expected_response_code) + + def tearDown(self): + # Disconnect the database + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get.py index 3c9dbed70..9cb0aaf36 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get.py @@ -17,35 +17,58 @@ 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 collation_utils +from unittest.mock import patch class CollationGetTestCase(BaseTestGenerator): """ This class will fetch new collation under schema node. """ skip_on_database = ['gpdb'] - scenarios = [ - # Fetching default URL for collation node. - ('Fetch collation Node URL', dict(url='/browser/collation/obj/')) - ] + scenarios = utils.generate_scenarios('get_collation', + collation_utils.test_cases) def setUp(self): super(CollationGetTestCase, self).setUp() self.schema_info = parent_node_dict["schema"][-1] self.schema_name = self.schema_info["schema_name"] + self.schema_id = self.schema_info["schema_id"] self.db_name = parent_node_dict["database"][-1]["db_name"] - coll_name = "collation_get_%s" % str(uuid.uuid4())[1:8] + self.server_id = self.schema_info["server_id"] + self.db_id = self.schema_info["db_id"] + self.coll_name = "collation_get_%s" % str(uuid.uuid4())[1:8] self.collation = collation_utils.create_collation(self.server, self.schema_name, - coll_name, + self.coll_name, self.db_name) + self.collation_id = self.collation[0] + + def get_collation_list(self): + """ + This functions returns the collation list + :return: collation list + """ + return self.tester.get( + self.url + str(utils.SERVER_GROUP) + '/' + str( + self.server_id) + '/' + + str(self.db_id) + '/' + str(self.schema_id) + '/', + content_type='html/json') + + def get_collation(self): + """ + This functions returns the collation list + :return: collation list + """ + return self.tester.get( + self.url + str(utils.SERVER_GROUP) + '/' + str( + self.server_id) + '/' + + str(self.db_id) + '/' + str(self.schema_id) + '/' + + str(self.collation_id), follow_redirects=True) def runTest(self): """ This function will fetch collation under schema node. """ - server_id = self.schema_info["server_id"] - db_id = self.schema_info["db_id"] db_con = database_utils.connect_database(self, utils.SERVER_GROUP, - server_id, - db_id) + self.server_id, + self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") @@ -54,16 +77,29 @@ class CollationGetTestCase(BaseTestGenerator): self.schema_name) if not schema_response: raise Exception("Could not find the schema.") - collation_id = self.collation[0] - schema_id = self.schema_info["schema_id"] - get_response = self.tester.get( - self.url + str(utils.SERVER_GROUP) + '/' + str( - server_id) + '/' + - str(db_id) + '/' + str(schema_id) + '/' + str(collation_id), - content_type='html/json') - self.assertEquals(get_response.status_code, 200) - # Disconnect database to delete it - database_utils.disconnect_database(self, server_id, db_id) + + if self.is_positive_test: + if hasattr(self, "collation_list"): + response = self.get_collation_list() + else: + response = self.get_collation() + else: + if hasattr(self, "error_fetching_collation"): + with patch(self.mock_data["function_name"], + return_value=eval(self.mock_data["return_value"])): + if hasattr(self, "collation_list"): + response = self.get_collation_list() + else: + response = self.get_collation() + if hasattr(self, "wrong_collation_id"): + self.collation_id = 99999 + response = self.get_collation() + + actual_response_code = response.status_code + expected_response_code = self.expected_data['status_code'] + + self.assertEquals(actual_response_code, expected_response_code) def tearDown(self): - pass + # Disconnect database to delete it + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get_collation_function.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get_collation_function.py new file mode 100644 index 000000000..612be34cb --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get_collation_function.py @@ -0,0 +1,85 @@ +########################################################################## +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2020, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +########################################################################## + +import uuid + +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.utils.route import BaseTestGenerator +from regression import parent_node_dict +from regression.python_test_utils import test_utils as utils +from . import utils as collation_utils +from unittest.mock import patch + + +class CollationGetTestCase(BaseTestGenerator): + """ This class will fetch new collation under schema node. """ + skip_on_database = ['gpdb'] + scenarios = utils.generate_scenarios('get_collation_func', + collation_utils.test_cases) + + def setUp(self): + super(CollationGetTestCase, self).setUp() + self.schema_info = parent_node_dict["schema"][-1] + self.schema_name = self.schema_info["schema_name"] + self.schema_id = self.schema_info["schema_id"] + self.db_name = parent_node_dict["database"][-1]["db_name"] + self.server_id = self.schema_info["server_id"] + self.db_id = self.schema_info["db_id"] + self.coll_name = "collation_get_%s" % str(uuid.uuid4())[1:8] + self.collation = collation_utils.create_collation(self.server, + self.schema_name, + self.coll_name, + self.db_name) + self.collation_id = self.collation[0] + + def get_collation(self): + """ + This functions returns the collation list + :return: collation list + """ + return self.tester.get( + self.url + str(utils.SERVER_GROUP) + '/' + str( + self.server_id) + '/' + + str(self.db_id) + '/' + str(self.schema_id) + '/' + + str(self.collation_id), follow_redirects=True) + + def runTest(self): + """ This function will fetch collation under schema node. """ + db_con = database_utils.connect_database(self, + utils.SERVER_GROUP, + self.server_id, + self.db_id) + if not db_con['data']["connected"]: + raise Exception("Could not connect to database.") + + schema_response = schema_utils.verify_schemas(self.server, + self.db_name, + self.schema_name) + if not schema_response: + raise Exception("Could not find the schema.") + + if self.is_positive_test: + response = self.get_collation() + else: + if self.mocking_required: + return_value_object = eval(self.mock_data["return_value"]) + with patch(self.mock_data["function_name"], + side_effect=[return_value_object]): + response = self.get_collation() + + actual_response_code = response.status_code + expected_response_code = self.expected_data["status_code"] + self.assertEquals(actual_response_code, expected_response_code) + + def tearDown(self): + # Disconnect database to delete it + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get_nodes.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get_nodes.py new file mode 100644 index 000000000..ac890ce8c --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get_nodes.py @@ -0,0 +1,98 @@ +########################################################################## +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2020, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +########################################################################## + +import uuid + +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.utils.route import BaseTestGenerator +from regression import parent_node_dict +from regression.python_test_utils import test_utils as utils +from . import utils as collation_utils +from unittest.mock import patch + + +class CollationNodesTestCase(BaseTestGenerator): + """ This class will test node api for existing index""" + skip_on_database = ['gpdb'] + scenarios = utils.generate_scenarios('get_collation_nodes_and_node', + collation_utils.test_cases) + + def setUp(self): + super(CollationNodesTestCase, self).setUp() + self.schema_info = parent_node_dict["schema"][-1] + self.schema_name = self.schema_info["schema_name"] + self.db_name = parent_node_dict["database"][-1]["db_name"] + coll_name = "collation_get_%s" % str(uuid.uuid4())[1:8] + self.collation = collation_utils.create_collation(self.server, + self.schema_name, + coll_name, + self.db_name) + + def get_collation_nodes(self): + """ + This functions returns the collation nodes + :return: collation nodes + """ + return self.tester.get( + self.url + str(utils.SERVER_GROUP) + '/' + + str(self.server_id) + '/' + + str(self.db_id) + '/' + str(self.schema_id) + '/', + content_type='html/json') + + def get_collation_node(self): + """ + This functions returns the collation node + :return: collation node + """ + return self.tester.get( + self.url + str(utils.SERVER_GROUP) + '/' + + str(self.server_id) + '/' + + str(self.db_id) + '/' + str(self.schema_id) + '/' + + str(self.collation_id), content_type='html/json') + + def runTest(self): + """This function will call method providing node details""" + self.schema_id = self.schema_info["schema_id"] + self.server_id = self.schema_info["server_id"] + self.db_id = self.schema_info["db_id"] + db_con = database_utils.connect_database(self, utils.SERVER_GROUP, + self.server_id, self.db_id) + if not db_con['data']["connected"]: + raise Exception("Could not connect to database.") + schema_response = schema_utils.verify_schemas(self.server, + self.db_name, + self.schema_name) + if not schema_response: + raise Exception("Could not find the schema.") + self.collation_id = self.collation[0] + + if self.is_positive_test: + if hasattr(self, "node"): + response = self.get_collation_node() + else: + response = self.get_collation_nodes() + else: + if hasattr(self, "error_fetching_collation"): + with patch(self.mock_data["function_name"], + return_value=eval(self.mock_data["return_value"])): + if hasattr(self, "node"): + response = self.get_collation_node() + else: + response = self.get_collation_nodes() + + actual_response_code = response.status_code + expected_response_code = self.expected_data['status_code'] + self.assertEquals(actual_response_code, expected_response_code) + + def tearDown(self): + # Disconnect the database + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_put.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_put.py index a4324bd4c..d21c0b0bf 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_put.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_put.py @@ -18,36 +18,49 @@ 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 collation_utils +from unittest.mock import patch class CollationPutTestCase(BaseTestGenerator): """ This class will update added collation under schema node. """ skip_on_database = ['gpdb'] - scenarios = [ - # Fetching default URL for collation node. - ('Fetch collation Node URL', dict(url='/browser/collation/obj/')) - ] + scenarios = utils.generate_scenarios('update_collation', + collation_utils.test_cases) def setUp(self): super(CollationPutTestCase, self).setUp() self.schema_info = parent_node_dict["schema"][-1] self.schema_name = self.schema_info["schema_name"] self.db_name = parent_node_dict["database"][-1]["db_name"] + self.server_id = self.schema_info["server_id"] + self.db_id = self.schema_info["db_id"] + self.schema_id = self.schema_info["schema_id"] coll_name = "collation_get_%s" % str(uuid.uuid4())[1:8] self.collation = collation_utils.create_collation(self.server, self.schema_name, coll_name, self.db_name) + def update_collation(self): + """ + This function returns the collation delete response + :return: collation delete response + """ + return self.tester.put(self.url + str(utils.SERVER_GROUP) + + '/' + str(self.server_id) + '/' + + str(self.db_id) + '/' + str(self.schema_id) + + '/' + + str(self.collation_id), + data=json.dumps(self.test_data), + follow_redirects=True) + def runTest(self): """ This function will update collation under schema node. """ - server_id = self.schema_info["server_id"] - db_id = self.schema_info["db_id"] # Verify database db_con = database_utils.connect_database(self, utils.SERVER_GROUP, - server_id, - db_id) + self.server_id, + self.db_id) if not db_con['data']["connected"]: raise Exception("Could not connect to database.") # Verify schema @@ -63,23 +76,26 @@ class CollationPutTestCase(BaseTestGenerator): coll_name) if not collation_response: raise Exception("Could not find the collation.") + self.collation_id = self.collation[0] + self.test_data['id'] = self.collation_id - collation_id = self.collation[0] - schema_id = self.schema_info["schema_id"] - data = { - "description": "This is collation update comment", - "id": collation_id - } - put_response = self.tester.put(self.url + str(utils.SERVER_GROUP) + - '/' + str(server_id) + '/' + - str(db_id) + '/' + str(schema_id) + - '/' + - str(collation_id), - data=json.dumps(data), - follow_redirects=True) - self.assertEquals(put_response.status_code, 200) - # Disconnect database to delete it - database_utils.disconnect_database(self, server_id, db_id) + if self.is_positive_test: + put_response = self.update_collation() + else: + if hasattr(self, "error_updating_collation"): + with patch(self.mock_data["function_name"], + return_value=eval(self.mock_data["return_value"])): + put_response = self.update_collation() + + if hasattr(self, "internal_server_error"): + with patch(self.mock_data["function_name"], + return_value=eval(self.mock_data["return_value"])): + put_response = self.update_collation() + + actual_response_code = put_response.status_code + expected_response_code = self.expected_data['status_code'] + self.assertEquals(actual_response_code, expected_response_code) def tearDown(self): - pass + # Disconnect database to delete it + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_sql.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_sql.py new file mode 100644 index 000000000..ee5b301bc --- /dev/null +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_sql.py @@ -0,0 +1,96 @@ +########################################################################## +# +# pgAdmin 4 - PostgreSQL Tools +# +# Copyright (C) 2013 - 2020, The pgAdmin Development Team +# This software is released under the PostgreSQL Licence +# +########################################################################## + +import uuid + +from pgadmin.browser.server_groups.servers.databases.schemas.tests import \ + utils as schema_utils +from pgadmin.browser.server_groups.servers.databases.tests import utils as \ + database_utils +from pgadmin.utils.route import BaseTestGenerator +from regression import parent_node_dict +from regression.python_test_utils import test_utils as utils +from . import utils as collation_utils +from unittest.mock import patch + + +class CollationSqlTestCase(BaseTestGenerator): + """ This class will fetch new collation under schema node. """ + skip_on_database = ['gpdb'] + scenarios = utils.generate_scenarios('get_collation_sql', + collation_utils.test_cases) + + def setUp(self): + super(CollationSqlTestCase, self).setUp() + self.schema_info = parent_node_dict["schema"][-1] + self.schema_name = self.schema_info["schema_name"] + self.schema_id = self.schema_info["schema_id"] + self.db_name = parent_node_dict["database"][-1]["db_name"] + self.server_id = self.schema_info["server_id"] + self.db_id = self.schema_info["db_id"] + self.coll_name = "collation_get_%s" % str(uuid.uuid4())[1:8] + self.collation = collation_utils.create_collation(self.server, + self.schema_name, + self.coll_name, + self.db_name) + self.collation_id = self.collation[0] + + def get_collation_sql(self): + """ + This functions returns the collation sql + :return: collation sql + """ + return self.tester.get( + self.url + str(utils.SERVER_GROUP) + '/' + str( + self.server_id) + '/' + + str(self.db_id) + '/' + str(self.schema_id) + + '/' + str(self.collation_id), content_type='html/json') + + def get_collation_msql(self): + """ + This functions returns the collation sql + :return: collation sql + """ + return self.tester.get( + self.url + + str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' + + str(self.db_id) + '/' + str(self.schema_id), + content_type='html/json', follow_redirects=True + ) + + def runTest(self): + """ This function will fetch collation sql under schema node. """ + db_con = database_utils.connect_database(self, + utils.SERVER_GROUP, + self.server_id, + self.db_id) + if not db_con['data']["connected"]: + raise Exception("Could not connect to database.") + + schema_response = schema_utils.verify_schemas(self.server, + self.db_name, + self.schema_name) + if not schema_response: + raise Exception("Could not find the schema.") + + if self.is_positive_test: + response = self.get_collation_sql() + else: + if hasattr(self, "error_fetching_collation"): + with patch(self.mock_data["function_name"], + return_value=eval(self.mock_data["return_value"])): + response = self.get_collation_sql() + + actual_response_code = response.status_code + expected_response_code = self.expected_data['status_code'] + self.assertEquals(actual_response_code, expected_response_code) + + def tearDown(self): + # Disconnect database to delete it + database_utils.disconnect_database(self, self.server_id, self.db_id) diff --git a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/utils.py b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/utils.py index 2259e7da2..d34af0237 100644 --- a/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/utils.py +++ b/web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/utils.py @@ -11,9 +11,16 @@ from __future__ import print_function import sys import traceback +import json +import os + from regression.python_test_utils import test_utils as utils +CURRENT_PATH = os.path.dirname(os.path.realpath(__file__)) +with open(CURRENT_PATH + "/collations_test_data.json") as data_file: + test_cases = json.load(data_file) + def create_collation(server, schema_name, coll_name, db_name): """This function add the collation to schemas"""