def runTest(self):
""" This function will update event trigger 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.")
func_name = self.function_info[1]
func_response = trigger_funcs_utils.verify_trigger_function(
self.server,
self.db_name,
func_name)
if not func_response:
raise Exception("Could not find the trigger function.")
trigger_response = event_trigger_utils.verify_event_trigger(
self.server, self.db_name, self.trigger_name)
if not trigger_response:
raise Exception("Could not find event trigger.")
data = {
"comment": "This is event trigger update comment",
"id": self.event_trigger_id
}
put_response = self.tester.put(
self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' + str(self.db_id) +
'/' + str(self.event_trigger_id),
data=json.dumps(data),
follow_redirects=True)
self.assertEquals(put_response.status_code, 200)
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 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 a foreign "
"key constraint.")
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 a foreign "
"key constraint.")
self.local_table_name = "local_table_foreignkey_delete_%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)
self.foreign_table_name = "foreign_table_foreignkey_delete_%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_delete_%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 add new FTS configuration 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.")
self.fts_conf_name = "fts_conf_%s" % str(uuid.uuid4())[1:8]
data = \
{
"name": self.fts_conf_name,
"owner": self.server["username"],
"prsname": "%s.%s" % (self.schema_name, self.fts_parser_name),
"schema": self.schema_id,
"tokens": []
}
response = self.tester.post(
self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' + str(self.db_id) +
'/' + str(self.schema_id) + '/',
data=json.dumps(data),
content_type='html/json')
self.assertEquals(response.status_code, 200)
def runTest(self):
""" This function will fetch added event trigger 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.")
func_name = self.function_info[1]
func_response = trigger_funcs_utils.verify_trigger_function(
self.server,
self.db_name,
func_name)
if not func_response:
raise Exception("Could not find the trigger function.")
response = self.tester.get(
self.url +
str(utils.SERVER_GROUP) + '/' + str(self.server_id) + '/' +
str(self.db_id) + '/' + str(self.event_trigger_id),
content_type='html/json'
)
self.assertEquals(response.status_code, 200)
def runTest(self):
""" This function will update domain under schema node. """
db_id = self.database_info["db_id"]
server_id = self.database_info["server_id"]
db_con = database_utils.connect_database(self, utils.SERVER_GROUP,
server_id, db_id)
if not db_con['data']["connected"]:
raise Exception("Could not connect to database to get the domain.")
db_name = self.database_info["db_name"]
schema_response = schema_utils.verify_schemas(self.server,
db_name,
self.schema_name)
if not schema_response:
raise Exception("Could not find the schema to get the domain.")
domain_response = domain_utils.verify_domain(self.server,
db_name,
self.schema_id,
self.domain_name)
if not domain_response:
raise Exception("Could not find the domain to update.")
domain_id = self.domain_info[0]
data = {"description": "This is domain update comment",
"id": domain_id,
}
response = self.tester.put(
self.url + str(utils.SERVER_GROUP) + '/' +
str(server_id) + '/' +
str(db_id) + '/' +
str(self.schema_id) + '/' +
str(domain_id),
data=json.dumps(data),
follow_redirects=True)
self.assertEquals(response.status_code, 200)
# Disconnect the database
database_utils.disconnect_database(self, server_id, db_id)
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)
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.")
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)
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)
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)
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)
def runTest(self):
db_con = database_utils.connect_database(self,
test_utils.SERVER_GROUP,
self.encode_sid,
self.encode_did)
if not db_con["info"] == "Database connected.":
raise Exception("Could not connect to the database.")
# Initialize query tool
url = '/datagrid/initialize/query_tool/{0}/{1}/{2}'.format(
test_utils.SERVER_GROUP, self.encode_sid, self.encode_did)
response = self.tester.post(url)
self.assertEquals(response.status_code, 200)
response_data = json.loads(response.data.decode('utf-8'))
self.trans_id = response_data['data']['gridTransId']
# Check character
url = "/sqleditor/query_tool/start/{0}".format(self.trans_id)
sql = "select E'{0}';".format(self.test_str)
response = self.tester.post(url, data=json.dumps({"sql": sql}),
content_type='html/json')
self.assertEquals(response.status_code, 200)
url = '/sqleditor/poll/{0}'.format(self.trans_id)
response = self.tester.get(url)
self.assertEquals(response.status_code, 200)
response_data = json.loads(response.data.decode('utf-8'))
self.assertEquals(response_data['data']['rows_fetched_to'], 1)
database_utils.disconnect_database(self, self.encode_sid,
self.encode_did)
def setUp(self):
super(SynonymAddTestCase, 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 = "Synonyms are not supported by PG."
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 add synonym.")
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 the synonym.")
self.sequence_name = "test_sequence_synonym_%s" % \
str(uuid.uuid4())[1:8]
self.sequence_id = sequence_utils.create_sequences(
self.server, self.db_name, self.schema_name, self.sequence_name)
def runTest(self):
""" This function will delete FTS template present 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_response = fts_temp_utils.verify_fts_template(self.server,
self.db_name,
self.fts_temp_name)
if not fts_response:
raise Exception("Could not find the FTS template.")
delete_response = self.tester.delete(
self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' +
str(self.db_id) + '/' +
str(self.schema_id) + '/' +
str(self.fts_temp_id),
follow_redirects=True)
self.assertEquals(delete_response.status_code, 200)
def runTest(self):
"""This function will update 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.")
data = {"description": "This is foreign server update comment",
"id": self.fsrv_id}
put_response = 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), data=json.dumps(data),
follow_redirects=True)
self.assertEquals(put_response.status_code, 200)
def runTest(self):
"""This function will fetch 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.")
response = self.tester.get(self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' +
str(self.db_id) + '/' +
str(self.schema_id) + '/' +
str(self.ft_id),
content_type='html/json')
self.assertEquals(response.status_code, 200)
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"]
server_response = server_utils.connect_server(self, self.server_id)
if server_response["data"]["version"] < 90300 and "mview" in self.url:
message = "Materialized Views are not supported by PG9.2 " \
"and PPAS9.2 and below."
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 view.")
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 view.")
self.view_id = views_utils.create_view(self.server,
self.db_name,
self.schema_name,
self.sql_query,
self.view_name)
def runTest(self):
""" This function will update 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'])
response = cast_utils.verify_cast(connection, self.source_type,
self.target_type)
if len(response) == 0:
raise Exception("Could not find cast.")
data = {
"description": "This is cast update comment",
"id": self.cast_id
}
put_response = self.tester.put(
self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' + str(
self.db_id) +
'/' + str(self.cast_id),
data=json.dumps(data),
follow_redirects=True)
self.assertEquals(put_response.status_code, 200)
def set_up(obj):
"""Common set up function"""
from regression import parent_node_dict
obj.db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
obj.server_id = schema_info["server_id"]
obj.db_id = schema_info["db_id"]
obj.prorettypename = "event_trigger/trigger"
server_con = server_utils.connect_server(obj, obj.server_id)
if not server_con["info"] == "Server connected.":
raise Exception("Could not connect to server.")
if "version" in server_con["data"]:
obj.server_version = server_con["data"]["version"]
if server_con["data"]["version"] < 90300:
obj.prorettypename = "trigger"
if "type" in server_con["data"]:
obj.server_type = server_con["data"]["type"]
db_con = database_utils.connect_database(obj, utils.SERVER_GROUP,
obj.server_id,
obj.db_id)
if not db_con['data']["connected"]:
raise Exception("Could not connect to database.")
obj.schema_id = schema_info["schema_id"]
obj.schema_name = schema_info["schema_name"]
schema_response = schema_utils.verify_schemas(obj.server,
obj.db_name,
obj.schema_name)
if not schema_response:
raise Exception("Could not find the schema.")
return obj
def runTest(self):
"""This function will delete 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.")
delete_response = self.tester.delete(
self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' +
str(self.db_id) + '/' +
str(self.schema_id) + '/' +
str(self.ft_id),
follow_redirects=True)
self.assertEquals(delete_response.status_code, 200)
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 add a table.")
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.")
self.is_partition = False
if hasattr(self, 'server_min_version'):
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.server_min_version:
message = "Partitioned table are not supported by " \
"PPAS/PG 10.0 and below."
self.skipTest(message)
else:
self.is_partition = True
def runTest(self):
""" This function will add domain under schema node. """
db_id = self.database_info["db_id"]
server_id = self.database_info["server_id"]
db_con = database_utils.connect_database(self, utils.SERVER_GROUP,
server_id, db_id)
if not db_con['data']["connected"]:
raise Exception("Could not connect to database to get the domain.")
db_name = self.database_info["db_name"]
schema_response = schema_utils.verify_schemas(self.server,
db_name,
self.schema_name)
if not schema_response:
raise Exception("Could not find the schema to get the domain.")
domain_id = self.domain_info[0]
# Call GET API to verify the domain
get_response = self.tester.delete(
self.url + str(utils.SERVER_GROUP) + '/' +
str(server_id) + '/' +
str(db_id) + '/' +
str(self.schema_id) + '/' +
str(domain_id),
content_type='html/json')
self.assertEquals(get_response.status_code, 200)
# Disconnect the database
database_utils.disconnect_database(self, server_id, db_id)
def runTest(self):
""" This function will fetch FTS template present 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.")
response = self.tester.get(self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' +
str(self.db_id) + '/' +
str(self.schema_id) + '/' +
str(self.fts_temp_id),
content_type='html/json')
self.assertEquals(response.status_code, 200)
def setUp(self):
super(TriggersDeleteTestCase, 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"]
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 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 delete trigger.")
self.table_name = "table_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.func_name = "trigger_func_delete_%s" % str(uuid.uuid4())[1:8]
self.function_info = \
trigger_funcs_utils.create_trigger_function_with_trigger(
self.server, self.db_name, self.schema_name, self.func_name)
self.trigger_name = "test_trigger_delete_%s" % (str(uuid.uuid4())[1:8])
self.trigger_id = triggers_utils.create_trigger(self.server,
self.db_name,
self.schema_name,
self.table_name,
self.trigger_name,
self.func_name)
def setUp(self):
super(CheckConstraintAddTestCase, 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"]
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 check "
"constraint.")
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 check "
"constraint.")
self.table_name = "table_checkconstraint_add_%s" % \
(str(uuid.uuid4())[1:8])
self.table_id = tables_utils.create_table(self.server,
self.db_name,
self.schema_name,
self.table_name)
def runTest(self):
"""This function will add sequence(s) under schema node."""
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 sequence.")
schema_id = schema_info["schema_id"]
schema_name = schema_info["schema_name"]
schema_response = schema_utils.verify_schemas(self.server,
db_name,
schema_name)
if not schema_response:
raise Exception("Could not find the schema to add sequence.")
db_user = self.server["username"]
common_data = {
"relacl": [
{
"grantee": db_user,
"grantor": db_user,
"privileges":
[
{
"privilege_type": "r",
"privilege": True,
"with_grant": True
},
{
"privilege_type": "w",
"privilege": True,
"with_grant": False
},
{
"privilege_type": "U",
"privilege": True,
"with_grant": False
}
]
}
],
"schema": schema_name,
"seqowner": db_user,
}
self.data.update(common_data)
response = self.tester.post(
self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' + str(self.db_id) +
'/' + str(schema_id) + '/',
data=json.dumps(self.data),
content_type='html/json')
self.assertEquals(response.status_code, 200)
def setUp(self):
super(LanguagesAddTestCase, self).setUp()
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 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_name)
if not fdw_response:
raise Exception("Could not find FDW.")
db_user = self.server["username"]
data = {
"fsrvacl": [
{
"grantee": db_user,
"grantor": db_user,
"privileges":
[
{
"privilege_type": "U",
"privilege": "true",
"with_grant": "false"
}
]
}
],
"fsrvoptions": [
{
"fsrvoption": "host",
"fsrvvalue": self.server['host']
},
{
"fsrvoption": "port",
"fsrvvalue": str(self.server['port'])
},
{
"fsrvoption": "dbname",
"fsrvvalue": self.db_name
}
],
"fsrvowner": db_user,
"name": "test_fsrv_add_%s" % (str(uuid.uuid4())[1:8])
}
response = self.tester.post(
self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' + str(self.db_id) +
'/' + str(self.fdw_id) + '/',
data=json.dumps(data),
content_type='html/json')
self.assertEquals(response.status_code, 200)
def runTest(self):
""" This function will check messages return by query tool polling. """
database_info = parent_node_dict["database"][-1]
self.server_id = database_info["server_id"]
self.db_id = 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 the database.")
# Initialize query tool
url = '/datagrid/initialize/query_tool/{0}/{1}/{2}'.format(
utils.SERVER_GROUP, self.server_id, self.db_id)
response = self.tester.post(url)
self.assertEquals(response.status_code, 200)
response_data = json.loads(response.data.decode('utf-8'))
self.trans_id = response_data['data']['gridTransId']
cnt = 0
for s in self.sql:
print("Executing and polling with: " + self.print_messages[cnt])
# Start query tool transaction
url = '/sqleditor/query_tool/start/{0}'.format(self.trans_id)
response = self.tester.post(url, data=json.dumps({"sql": s}),
content_type='html/json')
self.assertEquals(response.status_code, 200)
# Query tool polling
url = '/sqleditor/poll/{0}'.format(self.trans_id)
response = self.tester.get(url)
self.assertEquals(response.status_code, 200)
response_data = json.loads(response.data.decode('utf-8'))
if self.expected_message[cnt] is not None:
# Check the returned messages
self.assertIn(self.expected_message[cnt],
response_data['data']['additional_messages'])
# Check the output
self.assertEquals(self.expected_result[cnt],
response_data['data']['result'][0][0])
cnt += 1
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self):
""" This function will update trigger function under database node. """
schema_info = parent_node_dict["schema"][-1]
server_id = schema_info["server_id"]
db_id = schema_info["db_id"]
func_name = "test_event_put_%s" % str(uuid.uuid4())[1:8]
server_con = server_utils.connect_server(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"] < 90300:
server_version = server_con["data"]["version"]
self.function_info = trigger_funcs_utils.create_trigger_function(
self.server, self.db_name, self.schema_name, func_name,
server_version)
db_con = database_utils.connect_database(self, utils.SERVER_GROUP,
server_id, 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.")
func_name = self.function_info[1]
func_response = trigger_funcs_utils.verify_trigger_function(
self.server,
self.db_name,
func_name)
if not func_response:
raise Exception("Could not find the trigger function to update"
" it's details.")
trigger_func_id = self.function_info[0]
data = {
"description": "This is trigger function update comment",
"id": trigger_func_id
}
put_response = self.tester.put(
self.url + str(utils.SERVER_GROUP) +
'/' + str(server_id) + '/' + str(db_id) + '/' +
str(self.schema_id) + '/' +
str(trigger_func_id),
data=json.dumps(data),
follow_redirects=True)
self.assertEquals(put_response.status_code, 200)
# Disconnect the database
database_utils.disconnect_database(self, server_id, db_id)
def setUp(self):
self.server_data = parent_node_dict["database"][-1]
self.server_id = self.server_data["server_id"]
self.db_id = self.server_data['db_id']
self.db_name = self.server_data["db_name"]
self.lang_name = "language_%s" % str(uuid.uuid4())[1:8]
db_con = database_utils.connect_database(self,
utils.SERVER_GROUP,
self.server_id,
self.db_id)
if not db_con["info"] == "Database connected.":
raise Exception("Could not connect to database.")
self.language_id = language_utils.create_language(self.server,
self.db_name,
self.lang_name)
def runTest(self):
"""This function will 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.")
response = self.tester.get(
self.url + str(utils.SERVER_GROUP) + '/' + str(
self.server_id) + '/' +
str(self.db_id) + '/' + str(self.fdw_id),
content_type='html/json')
self.assertEquals(response.status_code, 200)
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 add a type.")
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 type.")
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 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_name)
if not fdw_response:
raise Exception("Could not find FDW.")
if self.is_positive_test:
response = self.get_handlers_fdw()
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.get_handlers_fdw()
self.assertEqual(response.status_code,
self.expected_data["status_code"])
def runTest(self):
""" This function will add cast under test database. """
super(CastsCreateGetFunctionsTestCase, self).runTest()
self.data = self.test_data
self.server_data = parent_node_dict["database"][-1]
self.server_id = self.server_data["server_id"]
self.db_id = self.server_data['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.")
if self.is_positive_test:
response = cast_utils.api_create_cast_get_functions(self)
cast_utils.assert_status_code(self, response)
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 = cast_utils.api_create_cast_get_functions(self)
cast_utils.assert_status_code(self, response)
cast_utils.assert_error_message(self, response)
def runTest(self):
""" This function will delete the FTS configurations 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.")
data = {'ids': self.fts_conf_ids}
delete_response = self.tester.delete(
self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) +
'/' + str(self.db_id) + '/' + str(self.schema_id) + '/',
follow_redirects=True,
data=json.dumps(data),
content_type='html/json')
self.assertEquals(delete_response.status_code, 200)
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.")
if self.is_positive_test:
response = self.get_fdw_sql()
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.get_fdw_sql()
if hasattr(self, "wrong_fdw_id"):
self.fdw_id = 99999
response = self.get_fdw_sql()
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEquals(actual_response_code, expected_response_code)
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 add a table.")
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.")
if hasattr(self, 'server_min_version'):
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.server_min_version:
self.skipTest(self.skip_msg)
def runTest(self):
"""This function will fetch foreign table under test database."""
# Create db connection
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.")
if self.is_positive_test:
if self.is_dependent:
self.url = self.url + 'dependent/'
response = ft_utils.api_get(self)
else:
self.url = self.url + 'dependency/'
response = ft_utils.api_get(self)
utils.assert_status_code(self, response)
def runTest(self):
""" This function will check dependents and dependencies
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.dependents_schema()
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEqual(actual_response_code, expected_response_code)
def runTest(self):
""" This function will delete FTS template present 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_response = fts_temp_utils.verify_fts_template(
self.server, self.db_name, self.fts_temp_name)
if not fts_response:
raise Exception("Could not find the FTS template.")
delete_response = self.tester.delete(
self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) +
'/' + str(self.db_id) + '/' + str(self.schema_id) + '/' +
str(self.fts_temp_id),
follow_redirects=True)
self.assertEqual(delete_response.status_code, 200)
negative_delete_response = self.tester.delete(
self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) +
'/' + str(self.db_id) + '/' + str(self.schema_id) + '/' + str(0),
follow_redirects=True)
self.assertEqual(negative_delete_response.status_code, 500)
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 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)
if not db_con['data']["connected"]:
raise Exception("Could not connect to database.")
# Verify schema
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.")
# Verify collation
coll_name = self.collation[1]
collation_response = collation_utils.verify_collation(
self.server, self.db_name, coll_name)
if not collation_response:
raise Exception("Could not find the collation.")
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)
def runTest(self):
"""This function will fetch foreign table under test database."""
# Create db connection
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.")
if self.is_positive_test:
response = ft_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"])]):
if self.is_list:
response = ft_utils.api_get(self, '')
else:
response = ft_utils.api_get(self)
elif 'ft_id' in self.data:
# Non-existing ft_id id
self.ft_id = self.data["ft_id"]
response = ft_utils.api_get(self)
# Assert response
utils.assert_status_code(self, response)
utils.assert_error_message(self, response)
def runTest(self):
""" This function will update extension added 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.")
response = extension_utils.verify_extension(self.server, self.db_name,
self.extension_name)
if not response:
raise Exception("Could not find extension.")
data = {
"schema": "public",
"id": self.extension_id
}
put_response = self.tester.put(
self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' + str(
self.db_id) +
'/' + str(self.extension_id),
data=json.dumps(data),
follow_redirects=True)
self.assertEquals(put_response.status_code, 200)
def runTest(self):
""" This function will update 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 get the domain.")
db_name = self.database_info["db_name"]
schema_response = schema_utils.verify_schemas(self.server, db_name,
self.schema_name)
if not schema_response:
raise Exception("Could not find the schema to get the domain.")
domain_response = domain_utils.verify_domain(self.server, db_name,
self.schema_id,
self.domain_name)
if not domain_response:
raise Exception("Could not find the domain to update.")
self.domain_id = self.domain_info[0]
self.test_data['id'] = self.domain_id
if self.is_positive_test:
response = self.update_domain()
else:
if hasattr(self, "error_updating_domain"):
return_value_object = eval(self.mock_data["return_value"])
with patch(self.mock_data["function_name"],
side_effect=[return_value_object]):
response = self.update_domain()
if hasattr(self, "error_in_db"):
with patch(self.mock_data["function_name"],
side_effect=eval(self.mock_data["return_value"])):
response = self.update_domain()
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEqual(actual_response_code, expected_response_code)
def runTest(self):
""" This function will delete schema under database node. """
server_id = self.database_info["server_id"]
db_id = self.database_info["db_id"]
db_con = database_utils.connect_database(self, utils.SERVER_GROUP,
server_id, db_id)
if not db_con['data']["connected"]:
raise Exception("Could not connect to database to delete the"
" schema.")
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 to update.")
db_user = self.server["username"]
data = {
"deffuncacl": {
"added": [{
"grantee":
db_user,
"grantor":
db_user,
"privileges": [{
"privilege_type": "X",
"privilege": True,
"with_grant": True
}]
}]
},
"defseqacl": {
"added": [{
"grantee":
db_user,
"grantor":
db_user,
"privileges": [{
"privilege_type": "r",
"privilege": True,
"with_grant": False
}, {
"privilege_type": "w",
"privilege": True,
"with_grant": False
}, {
"privilege_type": "U",
"privilege": True,
"with_grant": False
}]
}]
},
"deftblacl": {
"added": [{
"grantee":
"public",
"grantor":
db_user,
"privileges": [{
"privilege_type": "D",
"privilege": True,
"with_grant": False
}, {
"privilege_type": "x",
"privilege": True,
"with_grant": False
}]
}]
},
"id": schema_id
}
put_response = self.tester.put(self.url + str(utils.SERVER_GROUP) +
'/' + str(server_id) + '/' +
str(db_id) + '/' + str(schema_id),
data=json.dumps(data),
follow_redirects=True)
self.assertEquals(put_response.status_code, 200)
# Disconnect the database
database_utils.disconnect_database(self, server_id, db_id)
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)
# Check DB version
if "server_min_version" in self.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 check version")
if "type" in server_con["data"] and \
server_con["data"]["type"] == "pg":
self.skipTest("Compound Triggers are not supported by PG.")
elif server_con["data"]["type"] == "ppas" \
and server_con["data"]["version"] < self.data[
"server_min_version"]:
self.skipTest(self.data["skip_msg"])
if not db_con['data']["connected"]:
raise Exception("Could not connect to database to fetch the view.")
# 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 the view.")
# Create view
query = self.inventory_data['query']
self.view_name = "test_view_sql_%s" % (str(uuid.uuid4())[1:8])
self.view_id = views_utils.create_view(self.server,
self.db_name,
self.schema_name,
self.view_name,
query)
if hasattr(self, "trigger_fun_required"):
self.func_name = "trigger_func_get_%s" % str(uuid.uuid4())[1:8]
self.function_info = views_utils.\
create_trigger_function_with_trigger(self.server, self.db_name,
self.schema_name,
self.func_name)
self.trigger_name = \
"test_trigger_get_%s" % (str(uuid.uuid4())[1:8])
self.trigger_id = views_utils.create_trigger(self.server,
self.db_name,
self.schema_name,
self.view_name,
self.trigger_name,
self.func_name,
"a")
def runTest(self):
"""This function will add sequence(s) under schema node."""
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 sequence.")
schema_id = schema_info["schema_id"]
schema_name = schema_info["schema_name"]
schema_response = schema_utils.verify_schemas(self.server, db_name,
schema_name)
if not schema_response:
raise Exception("Could not find the schema to add sequence.")
db_user = self.server["username"]
data = {
"cache":
"1",
"cycled":
True,
"increment":
"1",
"maximum":
"100000",
"minimum":
"1",
"name":
"test_sequence_add_%s" % (str(uuid.uuid4())[1:8]),
"relacl": [{
"grantee":
db_user,
"grantor":
db_user,
"privileges": [{
"privilege_type": "r",
"privilege": True,
"with_grant": True
}, {
"privilege_type": "w",
"privilege": True,
"with_grant": False
}, {
"privilege_type": "U",
"privilege": True,
"with_grant": False
}]
}],
"schema":
schema_name,
"securities": [],
"seqowner":
db_user,
"start":
"100"
}
response = self.tester.post(
self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) +
'/' + str(self.db_id) + '/' + str(schema_id) + '/',
data=json.dumps(data),
content_type='html/json')
self.assertEquals(response.status_code, 200)
def runTest(self):
""" This function will add domain and verify the
reverse engineered sql. """
self.db_id = self.database_info["db_id"]
self.server_id = self.database_info["server_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 get the domain.")
db_name = self.database_info["db_name"]
schema_response = schema_utils.verify_schemas(self.server, db_name,
self.schema_name)
if not schema_response:
raise Exception("Could not find the schema to get the domain.")
self.domain_id = self.domain_info[0]
# Call GET API to fetch the domain sql
if self.is_positive_test:
get_response = self.get_sql()
expected_response_code = self.expected_data['status_code']
self.assertEqual(get_response.status_code, expected_response_code)
orig_sql = json.loads(get_response.data.decode('utf-8'))
# Replace multiple spaces with one space and check the expected sql
sql = re.sub('\s+', ' ', orig_sql).strip()
expected_sql = '-- DOMAIN: {0}.{1} -- DROP DOMAIN IF EXISTS ' \
'{0}.{1}; CREATE DOMAIN {0}.{1} {2} ' \
'ALTER DOMAIN {0}.{1} OWNER' \
' TO {3};'.format(self.schema_name,
self.test_data['domain_name'],
self.test_data['domain_sql'],
self.server["username"])
self.assertEqual(sql, expected_sql)
domain_utils.delete_domain(self.server, db_name, self.schema_name,
self.test_data['domain_name'])
# Verify the reverse engineered sql with creating domain with
# the sql we get from the server
domain_utils.create_domain_from_sql(self.server, db_name, orig_sql)
domain_utils.delete_domain(self.server, db_name, self.schema_name,
self.test_data['domain_name'])
else:
if hasattr(self, "internal_server_error"):
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
get_response = self.get_sql()
expected_response_code = self.expected_data['status_code']
self.assertEqual(get_response.status_code,
expected_response_code)
if hasattr(self, "wrong_domain_id"):
self.domain_id = 99999
get_response = self.get_sql()
expected_response_code = self.expected_data['status_code']
self.assertEqual(get_response.status_code,
expected_response_code)
def runTest(self):
""" This function will check update 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.")
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 to update.")
db_user = self.server["username"]
self.data = {
"deffuncacl": {
"added": [{
"grantee":
db_user,
"grantor":
db_user,
"privileges": [{
"privilege_type": "X",
"privilege": True,
"with_grant": True
}]
}]
},
"defseqacl": {
"added": [{
"grantee":
db_user,
"grantor":
db_user,
"privileges": [{
"privilege_type": "r",
"privilege": True,
"with_grant": False
}, {
"privilege_type": "w",
"privilege": True,
"with_grant": False
}, {
"privilege_type": "U",
"privilege": True,
"with_grant": False
}]
}]
},
"deftblacl": {
"added": [{
"grantee":
"public",
"grantor":
db_user,
"privileges": [{
"privilege_type": "D",
"privilege": True,
"with_grant": False
}, {
"privilege_type": "x",
"privilege": True,
"with_grant": False
}]
}]
},
"id": self.schema_id
}
if self.is_positive_test:
response = self.update_schema()
else:
if hasattr(self, "error_in_db"):
with patch(self.mock_data["function_name"],
side_effect=eval(self.mock_data["return_value"])):
response = self.update_schema()
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEqual(actual_response_code, expected_response_code)
def setUp(self):
super(CheckConstraintDeleteTestCase, 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 delete 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 delete a check "
"constraint.")
# Create table
self.table_name = "table_checkconstraint_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 constraint to delete
self.check_constraint_name = "test_checkconstraint_delete_%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)
# Cross check constraint creation
chk_constraint = check_constraint_utils.verify_check_constraint(
self.server, self.db_name, self.check_constraint_name)
if not chk_constraint:
raise Exception("Could not find the check constraint to delete.")
# In case of multiple constraints
if self.is_list:
# Create constraint to delete
self.check_constraint_name_2 = \
"test_checkconstraint_get_list_%s" % (str(uuid.uuid4())[1:8])
self.check_constraint_id_2 = \
check_constraint_utils.create_check_constraint(
self.server, self.db_name, self.schema_name,
self.table_name,
self.check_constraint_name_2)
# constraint list to delete
self.data['ids'] = [self.check_constraint_id,
self.check_constraint_id_2]
def runTest(self):
db_con = database_utils.connect_database(self, test_utils.SERVER_GROUP,
self._sid, self._did)
if not db_con["info"] == "Database connected.":
raise Exception("Could not connect to the database.")
# Initialize query tool
self.trans_id = str(random.randint(1, 9999999))
url = self.init_url.format(self.trans_id, test_utils.SERVER_GROUP,
self._sid, self._did)
response = self.tester.post(url)
self.assertEqual(response.status_code, 200)
res = self.initiate_sql_query_tool(self.trans_id, self.sql)
# If invalid tx test then make the Tx id invalid so that tests fails
if not self.is_valid_tx:
self.trans_id = self.trans_id + '007'
# Check character
url = self.donwload_url.format(self.trans_id)
# Disable the console logging from Flask logger
self.app.logger.disabled = True
if not self.is_valid and self.is_valid_tx:
# When user enters wrong query, poll will throw 500, so expecting
# 500, as poll is never called for a wrong query.
self.assertEqual(res.status_code, 500)
elif self.filename is None:
if self.download_as_txt:
with patch(
'pgadmin.tools.sqleditor.blueprint.'
'csv_field_separator.get',
return_value=';'), patch(
'time.time', return_value=1587031962.3808076):
response = self.tester.post(url, data={"query": self.sql})
headers = dict(response.headers)
# when valid query
self.assertEqual(response.status_code, 200)
csv_data = response.data.decode()
self.assertTrue(self.output_columns in csv_data)
self.assertTrue(self.output_values in csv_data)
self.assertIn('text/plain', headers['Content-Type'])
self.assertIn('1587031962.txt',
headers['Content-Disposition'])
else:
with patch('time.time', return_value=1587031962.3808076):
response = self.tester.post(url, data={"query": self.sql})
headers = dict(response.headers)
# when valid query
self.assertEqual(response.status_code, 200)
csv_data = response.data.decode()
self.assertTrue(self.output_columns in csv_data)
self.assertTrue(self.output_values in csv_data)
self.assertIn('text/csv', headers['Content-Type'])
self.assertIn('1587031962.csv',
headers['Content-Disposition'])
else:
response = self.tester.post(url,
data={
"query": self.sql,
"filename": self.filename
})
headers = dict(response.headers)
# Enable the console logging from Flask logger
self.app.logger.disabled = False
if self.is_valid:
# when valid query
self.assertEqual(response.status_code, 200)
csv_data = response.data.decode()
self.assertTrue(self.output_columns in csv_data)
self.assertTrue(self.output_values in csv_data)
self.assertIn('text/csv', headers['Content-Type'])
self.assertIn(self.filename, headers['Content-Disposition'])
elif not self.is_valid and self.is_valid_tx:
# When user enters wrong query
self.assertEqual(response.status_code, 200)
response_data = json.loads(response.data.decode('utf-8'))
self.assertFalse(response_data['data']['status'])
self.assertTrue(
'relation "this_table_does_not_exist" does not exist' in
response_data['data']['result'])
else:
# when TX id is invalid
self.assertEqual(response.status_code, 500)
# Close query tool
url = '/datagrid/close/{0}'.format(self.trans_id)
response = self.tester.delete(url)
self.assertEqual(response.status_code, 200)
database_utils.disconnect_database(self, self._sid, self._did)
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 and self.invalid:
if hasattr(self, "node"):
response = self.get_domain_constraint_node(
self.domain_constraint_id_invalid)
else:
response = self.get_domain_constraint_node("")
elif self.is_positive_test:
if hasattr(self, "node"):
response = self.get_domain_constraint_node(
self.domain_constraint_id)
else:
response = self.get_domain_constraint_node("")
else:
if hasattr(self, "error_fetching_domain_constraint"):
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
if hasattr(self, "node"):
response = self.get_domain_constraint_node(
self.domain_constraint_id)
else:
response = self.get_domain_constraint_node("")
if hasattr(self, "wrong_domain_constraint_id"):
self.domain_constraint_id = 99999
response = \
self.get_domain_constraint_node(self.domain_constraint_id)
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEquals(actual_response_code, expected_response_code)
def runTest(self):
""" This function will add trigger function under schema node. """
db_name = parent_node_dict["database"][-1]["db_name"]
schema_info = parent_node_dict["schema"][-1]
server_id = schema_info["server_id"]
db_id = schema_info["db_id"]
prorettypename = "event_trigger/trigger"
server_con = server_utils.connect_server(self, server_id)
if not server_con["info"] == "Server connected.":
raise Exception("Could not connect to server to add resource "
"groups.")
if "type" in server_con["data"]:
if server_con["data"]["version"] < 90300:
prorettypename = "trigger"
db_con = database_utils.connect_database(self, utils.SERVER_GROUP,
server_id, db_id)
if not db_con['data']["connected"]:
raise Exception("Could not connect to database to add a function.")
schema_id = schema_info["schema_id"]
schema_name = schema_info["schema_name"]
schema_response = schema_utils.verify_schemas(self.server,
db_name,
schema_name)
if not schema_response:
raise Exception("Could not find the schema to add a function.")
db_user = self.server["username"]
data = {
"acl": [
{
"grantee": db_user,
"grantor": db_user,
"privileges":
[
{
"privilege_type": "X",
"privilege": True,
"with_grant": True
}
]
}
],
"arguments": [],
"funcowner": db_user,
"lanname": "plpgsql",
"name": "test_abort_any_command",
"options": [],
"proleakproof": True,
"pronamespace": 2200,
"prorettypename": prorettypename,
"prosecdef": True,
"prosrc": "BEGIN RAISE EXCEPTION 'command % is disabled',"
" tg_tag; END;",
"provolatile": "s",
"seclabels": [],
"variables": [
{
"name": "enable_sort",
"value": True
}
]
}
# Get the type from data. We are adding two types
# i.e. event_trigger and trigger.
trigger_func_types = data['prorettypename'].split('/')
for func_type in trigger_func_types:
data['prorettypename'] = func_type
data["name"] = "test_event_add_%s" % str(uuid.uuid4())[1:6]
if schema_id:
data['pronamespace'] = schema_id
else:
schema_id = data['pronamespace']
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)
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")