class CheckConstraintGetDependenciesDependentsTestCase(BaseTestGenerator):
"""This class will fetch dependents/ dependencies for check constraint to
existing table """
url = '/browser/check_constraint/'
# Generates scenarios from cast_test_data.json file
scenarios = utils.generate_scenarios(
"check_constraint_dependencies_dependents",
check_constraint_utils.test_cases)
def setUp(self):
super(CheckConstraintGetDependenciesDependentsTestCase, self).setUp()
# Load test data
self.data = self.test_data
# Create db connection
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
self.db_id = 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 to fetch a check "
"constraint.")
# Create schema
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to fetch a check "
"constraint.")
# Create table
self.table_name = "table_checkconstraint_get_%s" % \
(str(uuid.uuid4())[1:8])
self.table_id = tables_utils.create_table(self.server, self.db_name,
self.schema_name,
self.table_name)
# Create constraint to fetch dependents/dependency
self.check_constraint_name = "test_checkconstraint_get_%s" % \
(str(uuid.uuid4())[1:8])
self.check_constraint_id = \
check_constraint_utils.create_check_constraint(
self.server, self.db_name, self.schema_name, self.table_name,
self.check_constraint_name)
def runTest(self):
"""This function will fetch dependents/ dependencies for check
constraint to existing table """
if self.is_positive_test:
if self.is_dependent:
self.url = self.url + 'dependent/'
response = check_constraint_utils.api_get(self)
else:
self.url = self.url + 'dependency/'
response = check_constraint_utils.api_get(self)
utils.assert_status_code(self, response)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class FDWDDeleteMultipleTestCase(BaseTestGenerator):
"""This class will delete foreign data wrappers under test database."""
skip_on_database = ['gpdb']
scenarios = utils.generate_scenarios('fdw_delete_multiple',
fdw_utils.test_cases)
def setUp(self):
""" This function will create extension and foreign data wrapper."""
super(FDWDDeleteMultipleTestCase, self).setUp()
self.schema_data = parent_node_dict['schema'][-1]
self.server_id = self.schema_data['server_id']
self.db_id = self.schema_data['db_id']
self.db_name = parent_node_dict["database"][-1]["db_name"]
self.schema_name = self.schema_data['schema_name']
self.fdw_names = ["fdw_{0}".format(str(uuid.uuid4())[1:8]),
"fdw_{0}".format(str(uuid.uuid4())[1:8])]
self.fdw_ids = [fdw_utils.create_fdw(self.server, self.db_name,
self.fdw_names[0]),
fdw_utils.create_fdw(self.server, self.db_name,
self.fdw_names[1])]
def delete_multiple(self, data):
"""
This function returns multiple fdw delete response
:param data: fdw ids to delete
:return: fdw delete response
"""
return self.tester.delete(self.url + str(utils.SERVER_GROUP) +
'/' + str(self.server_id) +
'/' + str(self.db_id) + '/',
follow_redirects=True,
data=json.dumps(data),
content_type='html/json')
def runTest(self):
"""This function will fetch foreign data wrapper present under test
database."""
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.")
fdw_response = fdw_utils.verify_fdw(self.server, self.db_name,
self.fdw_names[0])
if not fdw_response:
raise Exception("Could not find FDW.")
fdw_response = fdw_utils.verify_fdw(self.server, self.db_name,
self.fdw_names[1])
if not fdw_response:
raise Exception("Could not find FDW.")
data = {'ids': self.fdw_ids}
delete_response = self.delete_multiple(data)
self.assertEquals(delete_response.status_code,
self.expected_data['status_code'])
def tearDown(self):
"""This function disconnect the test database and drop added extension
and dependant objects."""
database_utils.disconnect_database(self, self.server_id,
self.db_id)
class ForeignKeyPutTestCase(BaseTestGenerator):
"""This class will update foreign key from existing table"""
url = '/browser/foreign_key/obj/'
# Generates scenarios
scenarios = utils.generate_scenarios("foreign_key_put",
fk_utils.test_cases)
def setUp(self):
# Load test data
self.data = self.test_data
# Create db connection
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
self.db_id = 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 to fetch a foreign "
"key constraint.")
# Create schema
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to fetch a foreign "
"key constraint.")
# Create local table
self.local_table_name = "local_table_foreignkey_get_%s" % \
(str(uuid.uuid4())[1:8])
self.local_table_id = tables_utils.create_table(
self.server, self.db_name, self.schema_name, self.local_table_name)
# Create foreign table
self.foreign_table_name = "foreign_table_foreignkey_get_%s" % \
(str(uuid.uuid4())[1:8])
self.foreign_table_id = tables_utils.create_table(
self.server, self.db_name, self.schema_name,
self.foreign_table_name)
# Create foreign key
self.foreign_key_name = "test_foreignkey_get_%s" % \
(str(uuid.uuid4())[1:8])
if "query" in self.inventory_data:
query = self.inventory_data["query"]
else:
query = None
self.foreign_key_id = fk_utils.create_foreignkey(
self.server, self.db_name, self.schema_name, self.local_table_name,
self.foreign_table_name, query)
def runTest(self):
"""This function will update foreign key attached to table column."""
self.data["oid"] = self.foreign_key_id
if self.is_positive_test:
response = fk_utils.api_put(self)
# Assert response
utils.assert_status_code(self, response)
else:
if self.mocking_required:
with patch(self.mock_data["function_name"],
side_effect=[eval(self.mock_data["return_value"])]):
response = fk_utils.api_put(self)
# Assert response
utils.assert_status_code(self, response)
utils.assert_error_message(self, response)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class SchemaGetTestCase(BaseTestGenerator):
""" This class will add new schema under database node. """
scenarios = utils.generate_scenarios('schema_get', schema_utils.test_cases)
def get_schema(self):
"""
This function returns the schema get response
:return: schema get response
"""
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_schema_list(self):
"""
This functions returns the schema list
:return: schema list
"""
return self.tester.get(self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' + str(self.db_id) +
'/',
content_type='html/json')
def runTest(self):
""" This function will delete schema under database node. """
schema = parent_node_dict["schema"][-1]
self.db_id = schema["db_id"]
self.server_id = schema["server_id"]
server_response = server_utils.connect_server(self, self.server_id)
if not server_response["data"]["connected"]:
raise Exception("Could not connect to server to connect the"
" database.")
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 to get the schema.")
self.schema_id = schema["schema_id"]
if self.is_positive_test:
if hasattr(self, "schema_list"):
response = self.get_schema_list()
else:
response = self.get_schema()
else:
if hasattr(self, "error_fetching_schema"):
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
if hasattr(self, "schema_list"):
response = self.get_schema_list()
else:
response = self.get_schema()
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEqual(actual_response_code, expected_response_code)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class ConstraintDeleteMultipleTestCase(BaseTestGenerator):
"""This class will delete constraints under table node."""
url = '/browser/constraints/obj/'
# Generates scenarios from cast_test_data.json file
scenarios = utils.generate_scenarios("constraints_get",
constraints_utils.test_cases)
# scenarios = [
# # Fetching default URL for table node.
# ('Get Constraints', dict(url='/browser/constraints/obj/'))
# ]
def setUp(self):
# Load test data
self.data = self.test_data
# Create db connection
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
self.db_id = 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 to add a table.")
# Create schema
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to add a table.")
# Create table
self.table_name = "table_constraint_delete_%s" % \
(str(uuid.uuid4())[1:8])
self.table_id = tables_utils.create_table(self.server, self.db_name,
self.schema_name,
self.table_name)
# Create Check Constraints
self.check_constraint_name = "test_constraint_delete_%s" % \
(str(uuid.uuid4())[1:8])
self.check_constraint_id = \
chk_constraint_utils.create_check_constraint(
self.server, self.db_name, self.schema_name, self.table_name,
self.check_constraint_name)
self.check_constraint_name_1 = "test_constraint_delete1_%s" % (str(
uuid.uuid4())[1:8])
self.check_constraint_id_1 = \
chk_constraint_utils.create_check_constraint(
self.server, self.db_name, self.schema_name, self.table_name,
self.check_constraint_name_1)
# Create Exclusion Constraint
self.exclustion_constraint_name = "test_exclusion_get_%s" % (str(
uuid.uuid4())[1:8])
self.exclustion_constraint_id = \
exclusion_utils.create_exclusion_constraint(
self.server, self.db_name, self.schema_name, self.table_name,
self.exclustion_constraint_name
)
# Create Foreign Key
self.foreign_table_name = "foreign_table_foreignkey_get_%s" % \
(str(uuid.uuid4())[1:8])
self.foreign_table_id = tables_utils.create_table(
self.server, self.db_name, self.schema_name,
self.foreign_table_name)
self.foreign_key_name = "test_foreignkey_get_%s" % \
(str(uuid.uuid4())[1:8])
self.foreign_key_id = fk_utils.create_foreignkey(
self.server, self.db_name, self.schema_name, self.table_name,
self.foreign_table_name)
# Create Primary Key
self.primary_key_name = "test_primary_key_get_%s" % \
(str(uuid.uuid4())[1:8])
self.primary_key_id = \
index_constraint_utils.create_index_constraint(
self.server, self.db_name, self.schema_name, self.table_name,
self.primary_key_name, "PRIMARY KEY")
# Create Unique Key constraint
self.unique_constraint_name = "test_unique_constraint_get_%s" % (str(
uuid.uuid4())[1:8])
self.unique_constraint_id = \
index_constraint_utils.create_index_constraint(
self.server, self.db_name, self.schema_name, self.table_name,
self.unique_constraint_name, "UNIQUE")
def runTest(self):
"""This function will delete constraints under table node."""
if self.is_positive_test:
response = constraints_utils.api_get(self)
# Assert response
utils.assert_status_code(self, response)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class ExclusionGetTestCase(BaseTestGenerator):
"""This class will fetch the existing exclusion constraint"""
url = '/browser/exclusion_constraint/obj/'
# Generates scenarios from cast_test_data.json file
scenarios = utils.generate_scenarios("exclusion_constraint_get",
exclusion_utils.test_cases)
def setUp(self):
# Load test data
self.data = self.test_data
# Create db connection
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
self.db_id = 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 to add a table.")
# Create schema
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to add a table.")
# Create table
self.table_name = "table_exclusion_%s" % (str(uuid.uuid4())[1:8])
self.table_id = tables_utils.create_table(self.server, self.db_name,
self.schema_name,
self.table_name)
# Create constraint to fetch
self.exclusion_constraint_name = \
"test_exclusion_delete_%s" % (str(uuid.uuid4())[1:8])
self.exclusion_constraint_id = exclusion_utils.\
create_exclusion_constraint(self.server, self.db_name,
self.schema_name, self.table_name,
self.exclusion_constraint_name)
# Cross check constraint creation
cross_check_res = exclusion_utils.verify_exclusion_constraint(
self.server, self.db_name, self.exclusion_constraint_name)
if not cross_check_res:
raise Exception("Could not find the exclusion constraint "
"to delete.")
# In case of multiple constraints
if self.is_list:
# Create constraint to delete
self.exclusion_constraint_name_2 = \
"test_exclconstraint_get_list_%s" % (str(uuid.uuid4())[1:8])
self.exclusion_constraint_id_2 = \
exclusion_utils.create_exclusion_constraint(
self.server, self.db_name, self.schema_name,
self.table_name,
self.exclusion_constraint_name_2)
def runTest(self):
"""This function will fetch check constraint to table."""
if self.is_positive_test:
if self.is_list:
response = exclusion_utils.api_get(self, '')
else:
response = exclusion_utils.api_get(self)
# Assert response
utils.assert_status_code(self, response)
else:
if self.mocking_required:
with patch(self.mock_data["function_name"],
side_effect=[eval(self.mock_data["return_value"])]):
response = exclusion_utils.api_get(self)
elif 'exclusion_constraint_id' in self.data:
self.exclusion_constraint_id = \
self.data["exclusion_constraint_id"]
response = exclusion_utils.api_get(self)
# Assert response
utils.assert_status_code(self, response)
utils.assert_error_message(self, response)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class GrantWizardSavePermissionsTestCase(BaseTestGenerator):
""" This will grant permission to user for specified database object. """
scenarios = utils.generate_scenarios('grant_wizard_save_permissions',
grant_wizard_utils.test_cases)
def setUp(self):
self.database_info = parent_node_dict["database"][-1]
self.db_name = self.database_info["db_name"]
self.did = self.database_info["db_id"]
self.sid = parent_node_dict["server"][-1]["server_id"]
db_con = database_utils.connect_database(self, utils.SERVER_GROUP,
self.sid, self.did)
if not db_con['data']["connected"]:
raise Exception("Could not connect to database to add a table.")
self.schema_id = parent_node_dict['schema'][-1]["schema_id"]
self.schema_name = parent_node_dict['schema'][-1]["schema_name"]
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 to add a table.")
self.table_name = "table_for_wizard%s" % (str(uuid.uuid4())[1:8])
self.table_id = tables_utils.create_table(self.server, self.db_name,
self.schema_name,
self.table_name)
self.test_data['objects'][-1]['name'] = self.table_name
self.test_data['objects'][-1]['name_with_args'] = self.table_name
self.test_data['objects'][-1]['nspname'] = self.schema_name
if self.server_information['type'] == 'ppas':
self.test_data['acl'][-1]['grantee'] = 'enterprisedb'
self.test_data['acl'][-1]['grantor'] = 'enterprisedb'
else:
self.test_data['acl'][-1]['grantee'] = 'postgres'
self.test_data['acl'][-1]['grantor'] = 'postgres'
def grant_permissions(self):
response = self.tester.post(self.url + str(self.sid) + '/' +
str(self.did) + '/',
data=json.dumps(self.test_data),
content_type='html/json',
follow_redirects=True)
return response
def runTest(self):
""" This function will grant permission for user under database
object. """
if self.is_positive_test:
response = self.grant_permissions()
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
else:
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
response = self.grant_permissions()
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEqual(actual_response_code, expected_response_code)
def tearDown(self):
"""This function disconnect database."""
database_utils.disconnect_database(self, self.sid, self.did)
class CollationSqlTestCase(BaseTestGenerator):
""" This class will fetch new collation under schema node. """
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.assertEqual(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)
class MViewsUpdateParameterTestCase(BaseTestGenerator):
"""This class will check materialized view refresh functionality."""
# Generates scenarios
scenarios = utils.generate_scenarios("mview_refresh",
views_utils.test_cases)
def setUp(self):
# Load test data
self.data = self.test_data
# Create db connection
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
self.db_id = 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 to update a mview.")
# Create schema
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to update a mview.")
query = self.inventory_data['query']
self.m_view_name = "test_mview_put_%s" % (str(uuid.uuid4())[1:8])
self.view_id = views_utils.create_view(self.server, self.db_name,
self.schema_name,
self.m_view_name, query)
def runTest(self):
"""This class will check materialized view refresh functionality"""
mview_response = views_utils.verify_view(self.server, self.db_name,
self.m_view_name)
if not mview_response:
raise Exception("Could not find the mview to update.")
if self.is_put_request:
# Check utility
url_from_test_data = self.url
self.url = 'browser/mview/check_utility_exists/'
response = views_utils.api_get(self)
if response.json['success'] == 0:
self.skipTest("Couldn't check materialized view refresh "
"functionality because utility/binary does "
"not exists.")
# reset self.url value
self.url = url_from_test_data
if self.is_positive_test:
response = views_utils.api_put(self)
# Assert response
utils.assert_status_code(self, response)
self.assertTrue('job_id' in response.json['data'])
else:
if 'm_view_id' in self.data:
self.view_id = self.data['m_view_id']
response = views_utils.api_put(self)
# Assert response
utils.assert_status_code(self, response)
utils.assert_error_message(self, response)
else:
# only check utility
response = views_utils.api_get(self)
# Assert response
utils.assert_status_code(self, response)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class DomainConstraintGetSqlTestCase(BaseTestGenerator):
""" This class will add new domain constraint under schema node. """
scenarios = utils.generate_scenarios('domain_constraints_get_sql',
domain_cons_utils.test_cases)
def setUp(self):
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
self.server_id = schema_info["server_id"]
self.db_id = schema_info["db_id"]
self.domain_name = "domain_%s" % (str(uuid.uuid4())[1:8])
self.domain_con_name = \
"test_domain_con_sql_%s" % (str(uuid.uuid4())[1:8])
self.domain_info = \
domain_cons_utils.create_domain(self.server,
self.db_name,
self.schema_name,
self.schema_id,
self.domain_name)
self.domain_constraint_id = \
domain_cons_utils.create_domain_constraints(self.server,
self.db_name,
self.schema_name,
self.domain_name,
self.domain_con_name)
def sql_domain_constraint(self):
"""
This function returns the domain constraint sql response
:return: domain constraint sql response
"""
return self.tester.get(
self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' +
str(self.db_id) + '/' +
str(self.schema_id) + '/' +
str(self.domain_id) + '/' +
str(self.domain_constraint_id),
follow_redirects=True)
def runTest(self):
""" This function will add domain constraint under test database. """
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.domain_id = self.domain_info[0]
domain_name = self.domain_info[1]
domain_response = domain_cons_utils.verify_domain(
self.server,
self.db_name,
self.schema_id,
domain_name)
if not domain_response:
raise Exception("Could not find the domain.")
domain_cons_response = domain_cons_utils.verify_domain_constraint(
self.server, self.db_name,
self.domain_con_name)
if not domain_cons_response:
raise Exception("Could not find domain constraint.")
if self.is_positive_test:
response = self.sql_domain_constraint()
else:
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.sql_domain_constraint()
if hasattr(self, "wrong_domain_constraint_id"):
self.domain_constraint_id = 99999
response = self.sql_domain_constraint()
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEqual(actual_response_code, expected_response_code)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class SchemaDeleteMultipleTestCase(BaseTestGenerator):
""" This class will add new schema under database node. """
scenarios = utils.generate_scenarios('schema_multiple_delete',
schema_utils.test_cases)
def setUp(self):
self.database_info = parent_node_dict["database"][-1]
self.db_name = self.database_info["db_name"]
# Change the db name, so that schema will create in newly created db
self.schema_names = [
"schema_get_%s" % str(uuid.uuid4())[1:8],
"schema_get_%s" % str(uuid.uuid4())[1:8]
]
connection = utils.get_db_connection(self.db_name,
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
self.schema_details = schema_utils.create_schema(
connection, self.schema_names[0])
connection = utils.get_db_connection(self.db_name,
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
self.schema_details_1 = schema_utils.create_schema(
connection, self.schema_names[1])
def runTest(self):
""" This function will delete schema under database node. """
self.server_id = self.database_info["server_id"]
self.db_id = self.database_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 to delete the"
" schema.")
schema_name = self.schema_details[1]
schema_response = schema_utils.verify_schemas(self.server,
self.db_name,
schema_name)
if not schema_response:
raise Exception("Could not find the schema to delete.")
schema_name = self.schema_details_1[1]
schema_response = schema_utils.verify_schemas(self.server,
self.db_name,
schema_name)
if not schema_response:
raise Exception("Could not find the schema to delete.")
data = {'ids': [self.schema_details[0], self.schema_details_1[0]]}
response = self.tester.delete(self.url + str(utils.SERVER_GROUP) +
'/' + str(self.server_id) + '/' +
str(self.db_id) + '/',
follow_redirects=True,
data=json.dumps(data),
content_type='html/json')
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)
class ForeignTablePutTestCase(BaseTestGenerator):
"""
This class will fetch foreign table under database node.
"""
# url
url = '/browser/foreign_table/obj/'
# Generates scenarios
scenarios = utils.generate_scenarios("foreign_table_put",
ft_utils.test_cases)
def setUp(self):
""" This function will create foreign data wrapper, foreign server
and foreign table. """
super(ForeignTablePutTestCase, self).setUp()
# Load test data
self.data = self.test_data
# Get parent schema info
self.schema_data = parent_node_dict['schema'][-1]
self.server_id = self.schema_data['server_id']
self.db_id = self.schema_data['db_id']
self.db_name = parent_node_dict["database"][-1]["db_name"]
self.schema_name = self.schema_data['schema_name']
self.schema_id = self.schema_data['schema_id']
# Create FDW, server & table
self.fdw_name = "fdw_%s" % (str(uuid.uuid4())[1:8])
self.fsrv_name = "fsrv_%s" % (str(uuid.uuid4())[1:8])
self.ft_name = "ft_%s" % (str(uuid.uuid4())[1:8])
self.fdw_id = fdw_utils.create_fdw(self.server, self.db_name,
self.fdw_name)
self.fsrv_id = fsrv_utils.create_fsrv(self.server, self.db_name,
self.fsrv_name, self.fdw_name)
if bool(self.inventory_data):
query = self.inventory_data['query']
self.ft_id = ft_utils.create_foreign_table(self.server,
self.db_name,
self.schema_name,
self.fsrv_name,
self.ft_name, query)
else:
self.ft_id = ft_utils.create_foreign_table(self.server,
self.db_name,
self.schema_name,
self.fsrv_name,
self.ft_name)
def runTest(self):
"""This function will update foreign table under test database."""
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.")
fsrv_response = fsrv_utils.verify_fsrv(self.server, self.db_name,
self.fsrv_name)
if not fsrv_response:
raise Exception("Could not find Foreign Server.")
ft_response = ft_utils.verify_foreign_table(self.server, self.db_name,
self.fsrv_name)
if not ft_response:
raise Exception("Could not find Foreign Table.")
self.data['id'] = self.ft_id
if self.is_positive_test:
response = ft_utils.api_put(self)
# Assert response
utils.assert_status_code(self, response)
else:
if self.mocking_required:
with patch(self.mock_data["function_name"],
side_effect=[eval(self.mock_data["return_value"])]):
response = ft_utils.api_put(self)
# Assert response
utils.assert_status_code(self, response)
utils.assert_error_message(self, response)
def tearDown(self):
""" This function disconnect the test database and delete test
foreign table object. """
ft_utils.delete_foregin_table(self.server, self.db_name,
self.schema_name, self.ft_name)
database_utils.disconnect_database(self, self.server_id, self.db_id)
class SchemaNodeAndNodesTestCase(BaseTestGenerator):
""" This class will add new schema under database node. """
scenarios = utils.generate_scenarios('schema_get_nodes',
schema_utils.test_cases)
def setUp(self):
self.database_info = parent_node_dict["database"][-1]
self.db_name = self.database_info["db_name"]
# 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,
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
self.schema_details = schema_utils.create_schema(connection,
self.schema_name)
def get_node_schema(self):
"""
This function returns the schema node response
:return: schema node response
"""
return self.tester.get(
self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) +
'/' + str(self.db_id) + '/' + str(self.schema_id),
follow_redirects=True)
def runTest(self):
""" This function will check node and nodes
of schema under database node. """
self.server_id = self.database_info["server_id"]
self.db_id = self.database_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.")
self.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)
if not schema_response:
raise Exception("Could not find the schema.")
if self.is_positive_test:
response = self.get_node_schema()
else:
if hasattr(self, "error_fetching_schema"):
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
response = self.get_node_schema()
if hasattr(self, "wrong_schema_id"):
self.schema_id = 99999
response = self.get_node_schema()
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEqual(actual_response_code, expected_response_code)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class TableAddTestCase(BaseTestGenerator):
""" This class will add new collation under schema node. """
url = '/browser/table/obj/'
# Generates scenarios
scenarios = utils.generate_scenarios("table_create",
tables_utils.test_cases)
def setUp(self):
# Load test data
self.data = self.test_data
# Check server version
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
if "server_min_version" in self.inventory_data:
server_con = server_utils.connect_server(self, self.server_id)
if not server_con["info"] == "Server connected.":
raise Exception("Could not connect to server to add "
"partitioned table.")
if server_con["data"]["version"] < \
self.inventory_data["server_min_version"]:
self.skipTest(self.inventory_data["skip_msg"])
# Create db connection
self.db_name = parent_node_dict["database"][-1]["db_name"]
self.db_id = 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 to add a table.")
# Create schema
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to add a table.")
def runTest(self):
""" This function will add table under schema node. """
if "table_name" in self.data:
self.table_name = self.data["table_name"]
else:
self.table_name = "test_table_add_%s" % (str(uuid.uuid4())[1:8])
db_user = self.server["username"]
# Get the common data
self.data.update(tables_utils.get_table_common_data())
if self.server_information and \
'server_version' in self.server_information and \
self.server_information['server_version'] >= 120000:
self.data['spcname'] = None
self.data.update({
"name":
self.table_name,
"relowner":
db_user,
"schema":
self.schema_name,
"relacl": [{
"grantee":
db_user,
"grantor":
db_user,
"privileges": [{
"privilege_type": "a",
"privilege": True,
"with_grant": True
}, {
"privilege_type": "r",
"privilege": True,
"with_grant": False
}, {
"privilege_type": "w",
"privilege": True,
"with_grant": False
}]
}]
})
# Add table
if self.is_positive_test:
response = tables_utils.api_create(self)
# Assert response
utils.assert_status_code(self, response)
else:
if self.mocking_required:
with patch(self.mock_data["function_name"],
side_effect=eval(self.mock_data["return_value"])):
response = tables_utils.api_create(self)
else:
if self.table_name == "":
del self.data["name"]
response = tables_utils.api_create(self)
# Assert response
utils.assert_status_code(self, response)
utils.assert_error_message(self, response)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class ForeignKeyAddTestCase(BaseTestGenerator):
"""This class will add foreign key to existing table"""
url = '/browser/foreign_key/obj/'
# Generates scenarios
scenarios = utils.generate_scenarios("foreign_key_create",
fk_utils.test_cases)
def setUp(self):
# Load test data
self.data = self.test_data
# Create db connection
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
self.db_id = 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 to add a foreign "
"key constraint.")
# Create schema
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to add a foreign "
"key constraint.")
# Create local table
self.local_table_name = "table_foreignkey_%s" % \
(str(uuid.uuid4())[1:8])
self.local_table_id = tables_utils.create_table(
self.server, self.db_name, self.schema_name, self.local_table_name)
# Create foreign table
self.foreign_table_name = "table_foreignkey_%s" % \
(str(uuid.uuid4())[1:8])
self.foreign_table_id = tables_utils.create_table(
self.server, self.db_name, self.schema_name,
self.foreign_table_name)
def runTest(self):
"""This function will add foreign key table column."""
# FK name
if "name" in self.data:
fk_name = self.data["name"] + (str(uuid.uuid4())[1:8])
self.data["name"] = fk_name
else:
fk_name = self.local_table_name + '_' + \
self.data["columns"][0]["local_column"] + '_fkey'
# FK table name
if "columns" in self.data:
self.data["columns"][0]["references"] = self.foreign_table_id
if self.is_positive_test:
response = fk_utils.api_create(self)
# Assert response
utils.assert_status_code(self, response)
# Verify in backend
cross_check_res = fk_utils.verify_foreignkey(
self.server, self.db_name, self.local_table_name, fk_name)
self.assertIsNotNone(cross_check_res,
"Could not find foreign key.")
else:
if self.mocking_required:
with patch(self.mock_data["function_name"],
side_effect=eval(self.mock_data["return_value"])):
response = fk_utils.api_create(self)
else:
response = fk_utils.api_create(self)
# Assert response
utils.assert_status_code(self, response)
utils.assert_error_message(self, response)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class UserMappingPutTestCase(BaseTestGenerator):
"""This class will update user mapping under foreign server node."""
skip_on_database = ['gpdb']
scenarios = utils.generate_scenarios('user_mapping_update',
um_utils.test_cases)
def setUp(self):
""" This function will create extension and foreign data wrapper."""
super(UserMappingPutTestCase, self).setUp()
self.schema_data = parent_node_dict['schema'][-1]
self.server_id = self.schema_data['server_id']
self.db_id = self.schema_data['db_id']
self.db_name = parent_node_dict["database"][-1]["db_name"]
self.schema_name = self.schema_data['schema_name']
self.extension_name = "cube"
self.fdw_name = "fdw_%s" % (str(uuid.uuid4())[1:8])
self.fsrv_name = "fsrv_%s" % (str(uuid.uuid4())[1:8])
self.extension_id = extension_utils.create_extension(
self.server, self.db_name, self.extension_name, self.schema_name)
self.fdw_id = fdw_utils.create_fdw(self.server, self.db_name,
self.fdw_name)
self.fsrv_id = fsrv_utils.create_fsrv(self.server, self.db_name,
self.fsrv_name, self.fdw_name)
self.um_id = um_utils.create_user_mapping(self.server, self.db_name,
self.fsrv_name)
def update_user_mapping(self):
"""
This functions update user mapping
:return: user mapping update request details
"""
return self.tester.put(self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' + str(self.db_id) +
'/' + str(self.fdw_id) + '/' +
str(self.fsrv_id) + '/' + str(self.um_id),
data=json.dumps(self.test_data),
follow_redirects=True)
def runTest(self):
"""This function will update user mapping present under test
database"""
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.")
fdw_response = fdw_utils.verify_fdw(self.server, self.db_name,
self.fdw_name)
if not fdw_response:
raise Exception("Could not find FDW.")
fsrv_response = fsrv_utils.verify_fsrv(self.server, self.db_name,
self.fsrv_name)
if not fsrv_response:
raise Exception("Could not find FSRV.")
um_response = um_utils.verify_user_mapping(self.server, self.db_name,
self.fsrv_name)
if not um_response:
raise Exception("Could not find user mapping.")
self.test_data["id"] = self.um_id
if self.is_positive_test:
put_response = self.update_user_mapping()
else:
if hasattr(self, "error_in_db"):
with patch(self.mock_data["function_name"],
side_effect=eval(self.mock_data["return_value"])):
put_response = self.update_user_mapping()
actual_response_code = put_response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEqual(actual_response_code, expected_response_code)
def tearDown(self):
"""This function disconnect the test database and drop added
extension and dependant objects."""
extension_utils.drop_extension(self.server, self.db_name,
self.extension_name)
database_utils.disconnect_database(self, self.server_id, self.db_id)
class SubscriptionGetTestCase(BaseTestGenerator):
"""This class will fetch the subscription under table node."""
scenarios = utils.generate_scenarios('sql_subscription',
subscription_utils.test_cases)
def setUp(self):
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
self.db_id = schema_info["db_id"]
self.server_version = schema_info["server_version"]
if self.server_version < 99999:
self.skipTest("Logical replication is not supported "
"for server version less than 10")
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 to delete subscription.")
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to delete "
"subscription.")
self.table_name = "table_column_%s" % (str(uuid.uuid4())[1:8])
self.table_id = tables_utils.create_table(self.server, self.db_name,
self.schema_name,
self.table_name)
self.subscription_name = "test_subscription_delete_%s" % (str(
uuid.uuid4())[1:8])
self.subscription_id = \
subscription_utils.create_subscription(self.server, self.db_name,
self.subscription_name)
def get_sql(self):
return self.tester.get(self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' + str(self.db_id) +
'/' + str(self.subscription_id),
content_type='html/json')
def runTest(self):
"""This function will fetch the subscription under table node."""
if self.is_positive_test:
response = self.get_sql()
else:
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
response = self.get_sql()
self.assertEqual(response.status_code,
self.expected_data["status_code"])
def tearDown(self):
subscription_utils.delete_subscription(self.server, self.db_name,
self.subscription_name)
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class FTSParsersEndFunctionTestCase(BaseTestGenerator):
""" This class will get the start functions FTS parsers
under test schema. """
scenarios = utils.generate_scenarios('start_functions_fts_parsers',
fts_parsers_utils.test_cases)
def setUp(self):
self.schema_data = parent_node_dict['schema'][-1]
self.server_id = self.schema_data['server_id']
self.db_id = self.schema_data['db_id']
self.schema_name = self.schema_data['schema_name']
self.schema_id = self.schema_data['schema_id']
self.extension_name = "postgres_fdw"
self.db_name = parent_node_dict["database"][-1]["db_name"]
self.db_user = self.server["username"]
self.func_name = "fts_parser_func_%s" % str(uuid.uuid4())[1:8]
self.fts_parser_name = "fts_parser_delete_%s" % (str(
uuid.uuid4())[1:8])
server_con = server_utils.connect_server(self, self.server_id)
if not server_con["info"] == "Server connected.":
raise Exception("Could not connect to server to add resource "
"groups.")
server_version = 0
if "type" in server_con["data"]:
if server_con["data"]["version"] < 90500:
message = "FTS Parsers are not supported by PG9.4 " \
"and PPAS9.4 and below."
self.skipTest(message)
self.function_info = fts_config_funcs_utils.create_trigger_function(
self.server, self.db_name, self.schema_name, self.func_name,
server_version)
self.fts_parser_id = fts_parsers_utils. \
create_fts_parser(
self.server, self.db_name, self.schema_name,
self.fts_parser_name)
def get_fts_parsers_start_functions(self):
"""
This functions returns the fts parsers start functions
:return: fts start functions node
"""
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 runTest(self):
""" This function will add new FTS parsers under test schema. """
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.")
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.")
fts_conf_response = fts_parsers_utils.verify_fts_parser(
self.server, self.db_name, self.fts_parser_name)
if not fts_conf_response:
raise Exception("Could not find the FTS Parsers.")
if self.is_positive_test:
response = self.get_fts_parsers_start_functions()
else:
if hasattr(self, "error_fetching_fts_parser"):
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
response = self.get_fts_parsers_start_functions()
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEqual(actual_response_code, expected_response_code)
def tearDown(self):
"""This function delete the fts_parser and disconnect the test
database."""
fts_parser_utils.delete_fts_parser(self.server, self.db_name,
self.schema_name,
self.fts_parser_name)
database_utils.disconnect_database(self, self.server_id, self.db_id)
class AddServerTest(BaseTestGenerator):
""" This class will add the servers under default server group. """
scenarios = utils.generate_scenarios('add_server',
servers_utils.test_cases)
def setUp(self):
pass
def create_server(self, url):
return self.tester.post(url,
data=json.dumps(self.server),
content_type='html/json')
def runTest(self):
""" This function will add the server under default server group."""
url = "{0}{1}/".format(self.url, utils.SERVER_GROUP)
# Add service name in the config
if 'connect_timeout' in self.test_data:
self.server['connect_timeout'] = self.test_data['connect_timeout']
elif 'shared' in self.test_data:
self.server['shared'] = self.test_data['shared']
elif 'service' in self.test_data:
self.server['service'] = self.test_data['service']
if hasattr(self, 'ssh_tunnel'):
self.server['use_ssh_tunnel'] = self.test_data['use_ssh_tunnel']
self.server['tunnel_host'] = self.test_data['tunnel_host']
self.server['tunnel_port'] = self.test_data['tunnel_port']
self.server['tunnel_username'] = self.test_data['tunnel_username']
if self.with_password:
self.server['tunnel_authentication'] = self.test_data[
'tunnel_authentication']
else:
self.server['tunnel_authentication'] = 1
self.server['tunnel_identity_file'] = 'pkey_rsa'
if self.save_password:
self.server['tunnel_password'] = self.test_data[
'tunnel_password']
if 'connect_now' in self.test_data:
self.server['connect_now'] = self.test_data['connect_now']
self.server['password'] = self.server['db_password']
if self.is_positive_test:
if hasattr(self, 'with_save'):
self.server['save_password'] = self.with_save
if hasattr(self, 'with_pwd') and not self.with_pwd:
# Remove the password from server object
db_password = self.server['db_password']
del self.server['db_password']
response = self.create_server(url)
self.assertEquals(response.status_code,
self.expected_data["status_code"])
response_data = json.loads(response.data.decode('utf-8'))
self.server_id = response_data['node']['_id']
if hasattr(self, 'with_pwd') and not self.with_pwd:
# Remove the password from server object
self.server['db_password'] = db_password
def tearDown(self):
"""This function delete the server from SQLite """
utils.delete_server_with_api(self.tester, self.server_id)
class RulesUpdateTestCase(BaseTestGenerator):
"""This class will update the rule under table node."""
scenarios = utils.generate_scenarios('update_rule',
rules_utils.test_cases)
def setUp(self):
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
self.db_id = 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 to delete rule.")
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to delete rule.")
self.table_name = "table_column_%s" % (str(uuid.uuid4())[1:8])
self.table_id = tables_utils.create_table(self.server, self.db_name,
self.schema_name,
self.table_name)
self.rule_name = "test_rule_delete_%s" % (str(uuid.uuid4())[1:8])
self.rule_id = rules_utils.create_rule(self.server, self.db_name,
self.schema_name,
self.table_name,
self.rule_name)
def update_rule(self, data):
return self.tester.put(
"{0}{1}/{2}/{3}/{4}/{5}/{6}".format(self.url, utils.SERVER_GROUP,
self.server_id, self.db_id,
self.schema_id, self.table_id,
self.rule_id),
data=json.dumps(data),
follow_redirects=True)
def runTest(self):
"""This function will update the rule under table node."""
rule_response = rules_utils.verify_rule(self.server, self.db_name,
self.rule_name)
data = {"id": self.rule_id,
"comment": "This is testing comment."
}
if not rule_response:
raise Exception("Could not find the rule to update.")
if self.is_positive_test:
if hasattr(self, "wrong_rule_id"):
self.rule_id = 9999
response = self.update_rule(data)
else:
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
if hasattr(self, "wrong_rule_id"):
self.rule_id = 9999
response = self.update_rule(data)
self.assertEqual(response.status_code,
self.expected_data["status_code"])
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class DebuggerPollExecutionResult(BaseTestGenerator):
""" This class will start debugger execution."""
scenarios = utils.generate_scenarios('poll_end_execution_result',
debugger_utils.test_cases)
def setUp(self):
super(DebuggerPollExecutionResult, self).setUp()
self.schema_data = parent_node_dict['schema'][-1]
self.server_id = self.schema_data['server_id']
self.db_id = self.schema_data['db_id']
self.schema_id = self.schema_data['schema_id']
local_self = funcs_utils.set_up(self)
self.test_data['funcowner'] = self.server["username"]
function_info = debugger_utils.create_function(self, utils)
self.func_id = json.loads(function_info.data)['node']['_id']
if self.add_extension:
debugger_utils.add_extension(self, utils, db_utils=db_utils)
init_debugger = debugger_utils.init_debugger_function(self)
self.trans_id = json.loads(init_debugger.data)['data']['trans_id']
if self.init_target:
debugger_utils.initialize_target(self, utils)
debugger_utils.start_listener(self, utils, db_utils)
self.port_no = debugger_utils.messages(self, utils, db_utils)
debugger_utils.start_execution(self, utils, db_utils)
def poll_execution_result(self):
return self.tester.get(self.url + str(self.trans_id) + '/',
content_type='application/json')
def runTest(self):
"""
This function will initialize the debugger for function and procedures.
"""
if self.is_positive_test:
response = self.poll_execution_result()
else:
if self.mocking_required:
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
response = self.poll_execution_result()
else:
response = self.poll_execution_result()
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEqual(actual_response_code, expected_response_code)
def tearDown(self):
"""This function delete the server from SQLite """
# debugger_utils.abort_debugger(self)
debugger_utils.close_debugger(self)
debugger_utils.delete_function(self, utils)
db_utils.disconnect_database(self, self.server_id, self.db_id)
class CompoundTriggersGetTestCase(BaseTestGenerator):
"""This class will get the compound trigger under table node."""
skip_on_database = ['gpdb']
scenarios = utils.generate_scenarios('get_compound_trigger',
compound_triggers_utils.test_cases)
def setUp(self):
super(CompoundTriggersGetTestCase, self).setUp()
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
self.db_id = schema_info["db_id"]
server_con = server_utils.connect_server(self, self.server_id)
if server_con:
if "type" in server_con["data"]:
if server_con["data"]["type"] == "pg":
message = "Compound Triggers are not supported by PG."
self.skipTest(message)
elif server_con["data"]["type"] == "ppas" and \
server_con["data"]["version"] < 120000:
message = "Compound Triggers are not supported by " \
"EPAS server less than 12"
self.skipTest(message)
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 to update a compound trigger.")
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to update a trigger.")
self.table_name = \
"table_compound_trigger_%s" % (str(uuid.uuid4())[1:8])
self.table_id = tables_utils.create_table(self.server, self.db_name,
self.schema_name,
self.table_name)
self.trigger_name = \
"test_compound_trigger_update_%s" % (str(uuid.uuid4())[1:8])
self.trigger_id = \
compound_triggers_utils.create_compound_trigger(self.server,
self.db_name,
self.schema_name,
self.table_name,
self.trigger_name)
def get_compound_trigger(self):
return self.tester.get("{0}{1}/{2}/{3}/{4}/{5}/{6}".format(
self.url, utils.SERVER_GROUP, self.server_id, self.db_id,
self.schema_id, self.table_id, self.trigger_id),
follow_redirects=True)
def runTest(self):
"""This function will get trigger under table node."""
trigger_response = \
compound_triggers_utils.verify_compound_trigger(self.server,
self.db_name,
self.trigger_name)
if not trigger_response:
raise Exception("Could not find the compound trigger to update.")
if self.is_positive_test:
if hasattr(self, "incorrect_compound_trigger_id"):
self.trigger_id = 9999
if hasattr(self, "pass_argument"):
url = "{0}{1}/{2}/{3}/{4}/{5}/{6}".format(
self.url, utils.SERVER_GROUP, self.server_id, self.db_id,
self.schema_id, self.table_id, self.trigger_id)
url = \
url + \
"?oid=17312&description=commaa&name=code&_=1589522392579"
response = self.tester.get(url, follow_redirects=True)
self.assertEqual(response.status_code,
self.expected_data["status_code"])
if hasattr(self, "table_nodes"):
self.trigger_id = ''
response = self.get_compound_trigger()
else:
response = self.get_compound_trigger()
else:
if hasattr(self, "dummy_dict"):
if hasattr(self, "table_nodes"):
self.trigger_id = ''
self.mock_data['return_value'] = [
(True, self.dummy_dict),
(False, self.expected_data["message"])
]
with patch(self.mock_data["function_name"],
side_effect=self.mock_data["return_value"]):
response = self.get_compound_trigger()
elif hasattr(self, "table_nodes"):
self.trigger_id = ''
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
response = self.get_compound_trigger()
else:
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
response = self.get_compound_trigger()
self.assertEqual(response.status_code,
self.expected_data["status_code"])
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class FTSParsersDependencyDependentTestCase(BaseTestGenerator):
""" This class will get the dependency and dependents FTS parsers
under test schema. """
scenarios = utils.generate_scenarios('dependency_dependent_fts_parsers',
fts_parsers_utils.test_cases)
def setUp(self):
self.schema_data = parent_node_dict['schema'][-1]
self.server_id = self.schema_data['server_id']
self.db_id = self.schema_data['db_id']
self.schema_name = self.schema_data['schema_name']
self.schema_id = self.schema_data['schema_id']
self.extension_name = "postgres_fdw"
self.db_name = parent_node_dict["database"][-1]["db_name"]
self.db_user = self.server["username"]
self.func_name = "fts_parsers_func_%s" % str(uuid.uuid4())[1:8]
self.fts_parsers_name = "fts_parsers_delete_%s" % (str(
uuid.uuid4())[1:8])
server_con = server_utils.connect_server(self, self.server_id)
if not server_con["info"] == "Server connected.":
raise Exception("Could not connect to server to add resource "
"groups.")
server_version = 0
if "type" in server_con["data"]:
if server_con["data"]["version"] < 90500:
message = "FTS Parsers are not supported by PG9.4 " \
"and PPAS9.4 and below."
self.skipTest(message)
self.function_info = fts_parser_funcs_utils.create_trigger_function(
self.server, self.db_name, self.schema_name, self.func_name,
server_version)
self.fts_parsers = fts_parsers_utils. \
create_fts_parser(
self.server, self.db_name, self.schema_name,
self.fts_parsers_name)
def runTest(self):
""" This function will add new FTS dictionaries under test schema. """
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.")
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.")
fts_dict_response = fts_parsers_utils.verify_fts_parser(
self.server, self.db_name, self.fts_parsers_name)
if not fts_dict_response:
raise Exception("Could not find the FTS Parsers.")
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.assertEqual(actual_response_code, expected_response_code)
def get_dependency_dependent(self):
"""
This function returns the fts parsers dependency and dependent
:return: fts parsers 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.fts_parsers),
follow_redirects=True)
def tearDown(self):
"""This function delete the fts_parser and disconnect the test
database."""
fts_parser_utils.delete_fts_parser(self.server, self.db_name,
self.schema_name,
self.fts_parsers_name)
database_utils.disconnect_database(self, self.server_id, self.db_id)
class IndexConstraintGetStasticsTestCase(BaseTestGenerator):
"""This class will fetch the index constraint(primary key or unique key)
statistics of table column"""
skip_on_database = ['gpdb']
# Generates scenarios
scenarios = utils.generate_scenarios("index_constraint_get_statistics",
index_constraint_utils.test_cases)
def setUp(self):
# Load test data
self.data = self.test_data
# Create db connection
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
self.db_id = 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 to add a "
"index constraint(primary key or unique key).")
# Create schema
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to add a index "
"constraint(primary key or unique key).")
# Create table
self.table_name = "table_indexconstraint_%s" % \
(str(uuid.uuid4())[1:8])
self.table_id = tables_utils.create_table(self.server,
self.db_name,
self.schema_name,
self.table_name)
# Create constraint
self.constraint_name = self.inventory_data["constraint_name"] + \
(str(uuid.uuid4())[1:8])
self.type = self.inventory_data["type"]
self.index_constraint_id = index_constraint_utils. \
create_index_constraint(self.server, self.db_name,
self.schema_name, self.table_name,
self.constraint_name, self.type)
def runTest(self):
"""This function will fetch the index constraint(primary key or
unique key) statistics of table column."""
if self.is_positive_test:
if self.is_list:
response = index_constraint_utils.api_get(self, '')
else:
response = index_constraint_utils.api_get(self)
# Assert response
utils.assert_status_code(self, response)
else:
if self.mocking_required:
with patch(self.mock_data["function_name"],
side_effect=[eval(self.mock_data["return_value"])]):
response = index_constraint_utils.api_get(self)
elif "index_constraint_id" in self.data:
self.index_constraint_id = self.data["index_constraint_id"]
response = index_constraint_utils.api_get(self)
# Assert response
utils.assert_status_code(self, response)
utils.assert_error_message(self, response)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class ForeignKeyGetDependenciesDependentsTestCase(BaseTestGenerator):
"""This class will fetch foreign key dependencies/dependents from
existing table """
url = '/browser/foreign_key/'
# Generates scenarios
scenarios = utils.generate_scenarios("foreign_key_dependencies_dependents",
fk_utils.test_cases)
def setUp(self):
# Load test data
self.data = self.test_data
# Create db connection
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
self.db_id = 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 to fetch a foreign "
"key constraint.")
# Create schema
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to fetch a foreign "
"key constraint.")
# Create local table
self.local_table_name = "local_table_foreignkey_get_%s" % \
(str(uuid.uuid4())[1:8])
self.local_table_id = tables_utils.create_table(
self.server, self.db_name, self.schema_name, self.local_table_name)
# Create foreign table
self.foreign_table_name = "foreign_table_foreignkey_get_%s" % \
(str(uuid.uuid4())[1:8])
self.foreign_table_id = tables_utils.create_table(
self.server, self.db_name, self.schema_name,
self.foreign_table_name)
# Create foreign key
self.foreign_key_name = "test_foreignkey_get_%s" % \
(str(uuid.uuid4())[1:8])
self.foreign_key_id = fk_utils.create_foreignkey(
self.server, self.db_name, self.schema_name, self.local_table_name,
self.foreign_table_name)
def runTest(self):
"""This function will fetch foreign key dependencies/dependents
attached to table column. """
if self.is_positive_test:
if self.is_dependent:
self.url = self.url + 'dependent/'
response = fk_utils.api_get(self)
else:
self.url = self.url + 'dependency/'
response = fk_utils.api_get(self)
# Assert response
utils.assert_status_code(self, response)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class LanguagesAddTestCase(BaseTestGenerator):
skip_on_database = ['gpdb']
scenarios = utils.generate_scenarios('create_language',
language_utils.test_cases)
def setUp(self):
super(LanguagesAddTestCase, self).setUp()
db_user = self.server['username']
self.data = self.test_data
self.data['name'] = "language_%s" % str(uuid.uuid4())[1:8]
self.data['lanowner'] = db_user
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"]
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.")
def runTest(self):
"""This function will add language under test database."""
actual_status_code = ''
expected_status_code = ''
if self.is_positive_test:
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"):
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
response = self.create_language()
actual_status_code = response.status_code
expected_status_code = self.expected_data["status_code"]
if hasattr(self, "error_in_properties"):
with patch(self.mock_data["function_name"],
side_effect=[eval(self.mock_data["return_value"])]):
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)
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')
def tearDown(self):
"""This function delete added language and
disconnect the test database."""
if self.is_positive_test 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)
class CompoundTriggersUpdateTestCase(BaseTestGenerator):
"""This class will update compound trigger under table node."""
scenarios = utils.generate_scenarios('update_compound_trigger',
compound_triggers_utils.test_cases)
def setUp(self):
super(CompoundTriggersUpdateTestCase, self).setUp()
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.server_id = schema_info["server_id"]
self.db_id = schema_info["db_id"]
server_con = server_utils.connect_server(self, self.server_id)
if server_con:
if "type" in server_con["data"]:
if server_con["data"]["type"] == "pg":
message = "Compound Triggers are not supported by PG."
self.skipTest(message)
elif server_con["data"]["type"] == "ppas" \
and server_con["data"]["version"] < 120000:
message = "Compound Triggers are not supported by " \
"EPAS server less than 12"
self.skipTest(message)
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 to update a compound trigger.")
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
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 to update a trigger.")
self.table_name = \
"table_compound_trigger_%s" % (str(uuid.uuid4())[1:8])
self.table_id = tables_utils.create_table(self.server, self.db_name,
self.schema_name,
self.table_name)
self.trigger_name = \
"test_compound_trigger_update_%s" % (str(uuid.uuid4())[1:8])
self.trigger_id = \
compound_triggers_utils.create_compound_trigger(self.server,
self.db_name,
self.schema_name,
self.table_name,
self.trigger_name)
def update_compound_trigger(self):
return self.tester.put("{0}{1}/{2}/{3}/{4}/{5}/{6}".format(
self.url, utils.SERVER_GROUP, self.server_id, self.db_id,
self.schema_id, self.table_id, self.trigger_id),
data=json.dumps(self.test_data),
follow_redirects=True)
def runTest(self):
"""This function will get trigger under table node."""
trigger_response = \
compound_triggers_utils.verify_compound_trigger(self.server,
self.db_name,
self.trigger_name)
if not trigger_response:
raise Exception("Could not find the compound trigger to update.")
if hasattr(self, 'disable_trigger') and self.disable_trigger:
compound_triggers_utils.enable_disable_compound_trigger(
self.server, self.db_name, self.schema_name, self.table_name,
self.trigger_name, False)
self.test_data.update({"id": self.trigger_id})
if self.is_positive_test:
if hasattr(self, "wrong_compound_trigger_id"):
self.trigger_id = 9999
response = self.update_compound_trigger()
elif hasattr(self, "new_compound_trigger_id"):
with patch(self.mock_data["function_name"],
side_effect=eval(self.mock_data["return_value"])):
response = self.update_compound_trigger()
elif hasattr(self, "dummy_dict"):
self.mock_data['return_value'] = [(True, self.dummy_dict),
(False, self.dummy_data)]
with patch(
self.mock_data["function_name"],
side_effect=self.mock_data["return_value"]), patch(
'pgadmin.utils.driver.psycopg2.connection.Connection.'
'execute_scalar',
side_effect=[(True, True), (True, "Mocked response")]):
response = self.update_compound_trigger()
else:
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
if hasattr(self, "wrong_compound_trigger_id"):
self.trigger_id = 9999
response = self.update_compound_trigger()
self.assertEqual(response.status_code,
self.expected_data["status_code"])
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class UserMappingGetMSQLTestCase(BaseTestGenerator):
"""This class will add user mapping under foreign server node."""
skip_on_database = ['gpdb']
scenarios = utils.generate_scenarios('user_mapping_get_msql',
um_utils.test_cases)
def setUp(self):
""" This function will create extension and foreign data wrapper."""
super(UserMappingGetMSQLTestCase, self).setUp()
self.schema_data = parent_node_dict['schema'][-1]
self.server_id = self.schema_data['server_id']
self.db_id = self.schema_data['db_id']
self.db_name = parent_node_dict["database"][-1]["db_name"]
self.schema_name = self.schema_data['schema_name']
self.extension_name = "cube"
self.fdw_name = "fdw_%s" % (str(uuid.uuid4())[1:8])
self.fsrv_name = "fsrv_%s" % (str(uuid.uuid4())[1:8])
self.extension_id = extension_utils.create_extension(
self.server, self.db_name, self.extension_name, self.schema_name)
self.fdw_id = fdw_utils.create_fdw(self.server, self.db_name,
self.fdw_name)
self.fsrv_id = fsrv_utils.create_fsrv(self.server, self.db_name,
self.fsrv_name, self.fdw_name)
self.um_id = um_utils.create_user_mapping(self.server, self.db_name,
self.fsrv_name)
def msql_user_mapping(self):
"""
This function returns the user mapping msql response
:return: user mapping msql response
"""
return self.tester.get(self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' + str(self.db_id) +
'/' + str(self.fdw_id) + '/' +
str(self.fsrv_id) + '/' + str(self.um_id),
follow_redirects=True)
def runTest(self):
"""This function will fetch foreign server present under test
database"""
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.")
fdw_response = fdw_utils.verify_fdw(self.server, self.db_name,
self.fdw_name)
if not fdw_response:
raise Exception("Could not find FDW.")
fsrv_response = fsrv_utils.verify_fsrv(self.server, self.db_name,
self.fsrv_name)
if not fsrv_response:
raise Exception("Could not find FSRV.")
um_response = um_utils.verify_user_mapping(self.server, self.db_name,
self.fsrv_name)
if not um_response:
raise Exception("Could not find user mapping.")
if self.is_positive_test:
response = self.msql_user_mapping()
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):
"""This function disconnect the test database and drop added
extension and dependant objects."""
extension_utils.drop_extension(self.server, self.db_name,
self.extension_name)
database_utils.disconnect_database(self, self.server_id, self.db_id)
class DomainAddTestCase(BaseTestGenerator):
""" This class will add new domain under schema node. """
scenarios = utils.generate_scenarios('domain_create',
domain_utils.test_cases)
def setUp(self):
self.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
self.schema_id = schema_info["schema_id"]
self.schema_name = schema_info["schema_name"]
self.server_id = schema_info["server_id"]
self.db_id = schema_info["db_id"]
def create_domain(self):
"""
This function create a domain and returns the created domain
response
:return: created domain 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 domain 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 to add collation.")
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 to add the collation.")
self.test_data['basensp'] = self.schema_name
self.test_data['owner'] = self.server["username"]
# Call POST API to add domain
if self.is_positive_test:
response = self.create_domain()
else:
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_domain()
if hasattr(self, "error_getting_doid"):
with patch(self.mock_data["function_name"],
side_effect=eval(self.mock_data["return_value"])):
response = self.create_domain()
if hasattr(self, "error_getting_scid"):
with patch(self.mock_data["function_name"],
side_effect=eval(self.mock_data["return_value"])):
response = self.create_domain()
expected_response_code = self.expected_data['status_code']
self.assertEquals(response.status_code, expected_response_code)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
class CastsMultipleDeleteTestCase(BaseTestGenerator):
""" This class will delete the cast node added under database node. """
skip_on_database = ['gpdb']
url = '/browser/cast/obj/'
scenarios = utils.generate_scenarios("cast_delete_multiple",
cast_utils.test_cases)
def setUp(self):
super(CastsMultipleDeleteTestCase, self).setUp()
self.inv_data = self.inventory_data
self.default_db = self.server["db"]
self.database_info = parent_node_dict['database'][-1]
self.db_name = self.database_info['db_name']
self.server["db"] = self.db_name
self.cast_id = cast_utils.create_cast(self.server,
self.inv_data["srctyp"],
self.inv_data["trgtyp"])
def runTest(self):
""" This function will delete added cast."""
self.server_id = self.database_info["server_id"]
self.db_id = self.database_info['db_id']
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.")
connection = utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'],
self.server['sslmode'])
casts_exists = cast_utils.verify_cast(connection,
self.inv_data["srctyp"],
self.inv_data["trgtyp"])
if not casts_exists:
raise Exception("Could not find cast.")
if self.is_positive_test:
response = cast_utils.api_delete_casts(self, [self.cast_id])
cast_utils.assert_status_code(self, response)
else:
if self.mocking_required:
with patch(self.mock_data["function_name"],
side_effect=[eval(self.mock_data["return_value"])]):
response = cast_utils.api_delete_casts(self,
[self.cast_id])
cast_utils.assert_status_code(self, response)
cast_utils.assert_error_message(self, response)
else:
response = cast_utils.api_delete_casts(self, [self.cast_id])
cast_utils.assert_status_code(self, response)
def tearDown(self):
""" Actually Delete cast """
if not self.is_positive_test:
cast_utils.api_delete_casts(self, [self.cast_id])
"""This function will disconnect test database."""
database_utils.disconnect_database(self, self.server_id,
self.db_id)
self.server['db'] = self.default_db
