IntenseWebs/pgadmin4
3
0
Fork 0
mirror of https://github.com/pgadmin-org/pgadmin4.git synced 2025-02-25 18:55:31 -06:00
Code Issues Packages Projects Releases Wiki Activity

Improve code coverage and API test cases for Collations. Fixes #5325

Browse Source
This commit is contained in:
Satish V 2020-06-11 11:12:41 +05:30 committed by Akshay Joshi
parent 21efe6f902
commit 82c4a4a03e
12 changed files with 1015 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
docs/en_US/release_notes_4_23.rst
View File

@ -14,6 +14,7 @@ New features
Housekeeping
************
| `Issue #5325 <https://redmine.postgresql.org/issues/5325>`_ - Improve code coverage and API test cases for Collations.
| `Issue #5574 <https://redmine.postgresql.org/issues/5574>`_ - Cleanup Windows build scripts and ensure Windows x64 builds will work.
Bug fixes

415
web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/collations_test_data.json Normal file
View File

@ -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
}
]
}

84
web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_add.py
View File

@ -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)

69
web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_delete.py
View File

@ -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)

52
web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_delete_multiple.py
View File

@ -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)

77
web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_dependency_dependent.py Normal file
View File

@ -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)

78
web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get.py
View File

@ -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)

85
web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get_collation_function.py Normal file
View File

@ -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)

98
web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_get_nodes.py Normal file
View File

@ -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)

66
web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_put.py
View File

@ -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)

96
web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/test_collation_sql.py Normal file
View File

@ -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)

7
web/pgadmin/browser/server_groups/servers/databases/schemas/collations/tests/utils.py
View File

@ -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"""