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 tearDown(self):
"""This function disconnect the test database and drop added extension.
"""
db_name = parent_node_dict["database"][-1]['db_name']
extension_utils.drop_extension(self.server, db_name, self.data['name'])
database_utils.disconnect_database(self, self.server_id,
self.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 tearDown(self):
"""This function delete added language and
disconnect the test database."""
language_utils.delete_language(self.server, self.db_name,
self.lang_name)
database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self):
""" This function will add trigger function under schema node. """
super(TriggerFuncAddTestCase, self).runTest()
self = funcs_utils.set_up(self)
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": self.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:8]
if self.schema_id:
data['pronamespace'] = self.schema_id
else:
self.schema_id = data['pronamespace']
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)
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self):
""" This function will update procedure under database node. """
super(ProcedurePutTestCase, self).setUp()
self = funcs_utils.set_up(self)
if self.server_type == "pg" and\
self.server_version < 110000:
message = "Procedures are not supported by PG < 110000."
self.skipTest(message)
func_name = "test_procedure_put_%s" % str(uuid.uuid4())[1:8]
proc_info = funcs_utils.create_procedure(
self.server, self.db_name, self.schema_name, func_name,
self.server_type, self.server_version)
proc_id = proc_info[0]
data = {
"description": "This is procedure update comment",
"id": proc_id
}
put_response = self.tester.put(
self.url + str(utils.SERVER_GROUP) +
'/' + str(self.server_id) + '/' + str(self.db_id) + '/' +
str(self.schema_id) + '/' +
str(proc_id),
data=json.dumps(data),
follow_redirects=True)
self.assertEquals(put_response.status_code, 200)
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self):
""" This function will delete procedure under database node. """
super(procedureDeleteTestCase, self).setUp()
self = funcs_utils.set_up(self)
if self.server_type == "pg" and\
self.server_version < 110000:
message = "Procedures are not supported by PG < 110000."
self.skipTest(message)
func_name = "test_procedure_delete_%s" % str(uuid.uuid4())[1:8]
proc_info = funcs_utils.create_procedure(
self.server, self.db_name, self.schema_name, func_name,
self.server_type, self.server_version)
proc_id = proc_info[0]
response = self.tester.delete(
self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' +
str(self.db_id) + '/' +
str(self.schema_id) + '/' + str(proc_id),
content_type='html/json'
)
self.assertEquals(response.status_code, 200)
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.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 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 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 update function under database node. """
super(FunctionPutTestCase, self).setUp()
self = funcs_utils.set_up(self)
func_name = "test_event_delete_%s" % str(uuid.uuid4())[1:8]
function_info = funcs_utils.create_function(
self.server, self.db_name, self.schema_name, func_name)
func_id = function_info[0]
data = {
"description": "This is a procedure update comment",
"id": func_id
}
put_response = self.tester.put(
self.url + str(utils.SERVER_GROUP) +
'/' + str(self.server_id) + '/' + str(self.db_id) + '/' +
str(self.schema_id) + '/' +
str(func_id),
data=json.dumps(data),
follow_redirects=True)
self.assertEquals(put_response.status_code, 200)
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
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)
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)
def tearDown(self):
"""This function disconnect the test database and drop added cast."""
connection = utils.get_db_connection(self.server_data['db_name'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'],
self.server['sslmode'])
cast_utils.drop_cast(connection, self.data["srctyp"],
self.data["trgtyp"])
database_utils.disconnect_database(self, self.server_id,
self.db_id)
def tearDown(self):
"""This function disconnect the test database and drop added cast."""
connection = utils.get_db_connection(self.server['db'],
self.server['username'],
self.server['db_password'],
self.server['host'],
self.server['port'])
cast_utils.drop_cast(connection, self.source_type,
self.target_type)
database_utils.disconnect_database(self, self.server_id,
self.db_id)
self.server['db'] = self.default_db
def runTest(self):
""" This function will add function under schema node. """
super(FunctionAddTestCase, self).runTest()
self = funcs_utils.set_up(self)
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": "sql",
"name": "test_function",
"options": [],
"proleakproof": True,
"pronamespace": 2200,
"prorettypename": "integer",
"prosecdef": True,
"prosrc": "SELECT 1;",
"probin": "$libdir/",
"provolatile": "s",
"seclabels": [],
"variables": []
}
data["name"] = "test_function_add_%s" % str(uuid.uuid4())[1:8]
if self.schema_id:
data['pronamespace'] = self.schema_id
else:
self.schema_id = data['pronamespace']
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)
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
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 runTest(self):
""" This function will delete function under database node. """
super(FunctionGetTestCase, self).setUp()
self = funcs_utils.set_up(self)
func_name = "test_function_get_%s" % str(uuid.uuid4())[1:8]
function_info = funcs_utils.create_function(
self.server, self.db_name, self.schema_name, func_name)
trigger_func_id = function_info[0]
response = self.tester.get(
self.url + str(utils.SERVER_GROUP) + '/' +
str(self.server_id) + '/' +
str(self.db_id) + '/' +
str(self.schema_id) + '/' + str(trigger_func_id),
content_type='html/json')
self.assertEquals(response.status_code, 200)
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self):
""" This function will delete 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_delete_%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.")
trigger_func_id = self.function_info[0]
response = self.tester.delete(
self.url + str(utils.SERVER_GROUP) + '/' + str(server_id) + '/' +
str(db_id) + '/' +
str(self.schema_id) + '/' + str(trigger_func_id),
content_type='html/json'
)
self.assertEquals(response.status_code, 200)
# Disconnect the database
database_utils.disconnect_database(self, server_id, db_id)
def tearDown(self):
"""This function disconnect the test database."""
database_utils.disconnect_database(self, self.server_id,
self.db_id)
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)
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 tearDown(self):
"""This function delete the FDW and disconnect the test database """
fdw_utils.delete_fdw(self.server, self.db_name, self.fdw_name)
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDownClass(cls):
# Disconnect the database
database_utils.disconnect_database(cls, cls.server_id, cls.db_id)
def tearDown(self):
"""This function will disconnect test database."""
database_utils.disconnect_database(self, self.server_id,
self.db_id)
self.server['db'] = self.default_db
def tearDownClass(cls):
# Disconnect the database
database_utils.disconnect_database(cls, cls.server_id, cls.db_id)
def runTest(self):
""" This function will add procedure under schema node. """
super(ProcedureAddTestCase, self).setUp()
self = funcs_utils.set_up(self)
if self.server_type == "pg" and\
self.server_version < 110000:
message = "Procedures are not supported by PG < 110000."
self.skipTest(message)
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": "sql",
"name": "test_pg_11_proc",
"options": [],
"proleakproof": True,
"pronamespace": 2200,
"prosecdef": True,
"prosrc": "BEGIN RAISE EXCEPTION 'command % is disabled',"
" tg_tag; END;",
"seclabels": [],
"variables": [
{
"name": "enable_sort",
"value": True
}
]
}
data["name"] = "test_proc_add_%s" % str(uuid.uuid4())[1:8]
if self.server_type == 'pg':
data['prosrc'] = 'SELECT 1;'
if self.schema_id:
data['pronamespace'] = self.schema_id
else:
self.schema_id = data['pronamespace']
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)
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
"""This function disconnect the test database."""
database_utils.disconnect_database(self, self.server_id,
self.db_id)
def tearDown(self):
"""This function disconnect the test database and drop added
extension."""
extension_utils.drop_extension(self.server, self.db_name,
self.extension_name)
database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self):
""" This function will add trigger function under schema node. """
super(TriggerFuncAddTestCase, self).runTest()
self = funcs_utils.set_up(self)
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": self.prorettypename,
"prosecdef": True,
"prosrc": "BEGIN RAISE EXCEPTION 'command % is disabled',"
" tg_tag; END;",
"provolatile": "s",
"seclabels": [],
"variables": [
{
"name": "enable_sort",
"value": True
}, {
"name": "search_path",
"value": "public, pg_temp"
}
]
}
# 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:8]
if self.schema_id:
data['pronamespace'] = self.schema_id
else:
self.schema_id = data['pronamespace']
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.assertEqual(response.status_code, 200)
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
"""This function disconnect database."""
database_utils.disconnect_database(self, self.sid, self.did)
def runTest(self):
""" This function will add procedure under schema node. """
super(ProcedureAddTestCase, self).setUp()
self = funcs_utils.set_up(self)
if self.server_type == "pg" and\
self.server_version < 110000:
message = "Procedures are not supported by PG < 110000."
self.skipTest(message)
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":
"sql",
"name":
"test_pg_11_proc",
"options": [],
"proleakproof":
True,
"pronamespace":
2200,
"prosecdef":
True,
"prosrc":
"BEGIN RAISE EXCEPTION 'command % is disabled',"
" tg_tag; END;",
"seclabels": [],
"variables": [{
"name": "enable_sort",
"value": True
}, {
"name": "search_path",
"value": "public, pg_temp"
}]
}
data["name"] = "test_proc_add_%s" % str(uuid.uuid4())[1:8]
if self.server_type == 'pg':
data['prosrc'] = 'SELECT 1;'
if self.schema_id:
data['pronamespace'] = self.schema_id
else:
self.schema_id = data['pronamespace']
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.assertEqual(response.status_code, 200)
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
"""This function disconnect the test database and drop added cast."""
if self.is_positive_test:
database_utils.disconnect_database(self, self.server_id,
self.db_id)
def tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
"""This function disconnect the test database and drop
foreign data wrapper and dependant objects."""
fdw_utils.delete_fdw(self.server, self.db_name, self.fdw_name)
database_utils.disconnect_database(self, self.server_id,
self.db_id)
def tearDown(self):
# Disconnect the database
extension_utils.drop_extension(self.server, self.db_name,
self.extension_name)
database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self):
""" This function will add trigger function under schema node. """
super(TriggerFuncAddTestCase, self).runTest()
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:8]
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 tearDown(self):
publication_utils.delete_publication(self.server, self.db_name,
self.publication_name)
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self):
""" This function will add function under schema node. """
super(FunctionAddTestCase, self).runTest()
self = funcs_utils.set_up(self)
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":
"sql",
"name":
"test_function",
"options": [],
"proleakproof":
True,
"pronamespace":
2200,
"prorettypename":
"integer",
"prosecdef":
True,
"prosrc":
"SELECT 1;",
"probin":
"$libdir/",
"provolatile":
"s",
"seclabels": [],
"variables": []
}
data["name"] = "test_function_add_%s" % str(uuid.uuid4())[1:8]
if self.schema_id:
data['pronamespace'] = self.schema_id
else:
self.schema_id = data['pronamespace']
if self.server_version >= 120000:
support_function_name = 'supportfunc_%s' % str(uuid.uuid4())[1:8]
support_func = funcs_utils.create_support_internal_function(
self.server, self.db_name, self.schema_name,
support_function_name)
data['prosupportfuc'] = support_function_name
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)
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
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)
def tearDown(self):
# Close query tool
self._close_query_tool()
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
"""This function disconnect the test database and drop added foreign
data wrapper."""
extension_utils.drop_extension(self.server, self.db_name,
self.extension_name)
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
"""This function disconnect the test database and drop added extension.
"""
db_name = parent_node_dict["database"][-1]['db_name']
extension_utils.drop_extension(self.server, db_name, self.data['name'])
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
"""This function delete added language and
disconnect the test database."""
language_utils.delete_language(self.server, self.db_name,
self.lang_name)
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
"""This function delete the FDW and disconnect the test database """
fdw_utils.delete_fdw(self.server, self.db_name, self.fdw_name)
database_utils.disconnect_database(self, self.server_id,
self.db_id)
def tearDown(self):
database_utils.disconnect_database(
self, self.server_information['server_id'],
self.server_information['db_id'])
def tearDown(self):
"""This function delete the server from SQLite """
debugger_utils.close_debugger(self)
debugger_utils.delete_function(self, utils)
db_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
# Disconnect the database
subscription_utils.delete_subscription(self.server, self.db_name,
self.subscription_name)
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
# Disconnect database to delete it
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
"""This function delete the server from SQLite """
db_utils.disconnect_database(self, self.server_id, self.db_id)
def runTest(self):
""" This function will add function under schema node. """
super(FunctionAddTestCase, self).runTest()
self = funcs_utils.set_up(self)
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": "sql",
"name": "test_function",
"options": [],
"proleakproof": True,
"pronamespace": 2200,
"prorettypename": "integer",
"prosecdef": True,
"prosrc": "SELECT 1;",
"probin": "$libdir/",
"provolatile": "s",
"seclabels": [],
"variables": [{
"name": "search_path",
"value": "public, pg_temp"
}]
}
data["name"] = "test_function_add_%s" % str(uuid.uuid4())[1:8]
if self.schema_id:
data['pronamespace'] = self.schema_id
else:
self.schema_id = data['pronamespace']
if self.server_version >= 120000:
support_function_name = 'supportfunc_%s' % str(uuid.uuid4())[1:8]
funcs_utils.create_support_internal_function(
self.server,
self.db_name,
self.schema_name,
support_function_name
)
data['prosupportfuc'] = support_function_name
if self.is_positive_test:
response = self.create_function(data)
else:
if hasattr(self, 'is_mock_function'):
def _get_sql(self, **kwargs):
return False, ''
with patch.object(FunctionView,
self.mock_data["function_name"],
new=_get_sql):
response = self.create_function(data)
else:
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
response = self.create_function(data)
self.assertEqual(response.status_code,
self.expected_data['status_code'])
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
database_utils.disconnect_database(
self, self.server_information['server_id'],
self.server_information['db_id'])
self.test_config_db_conn.close()
def tearDown(self):
"""This function will disconnect test database."""
database_utils.disconnect_database(self, self.server_id, self.db_id)
self.server['db'] = self.default_db
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 tearDown(self):
# Disconnect the database
database_utils.disconnect_database(self, self.server_id, self.db_id)
def tearDown(self):
"""Close debugger connection."""
debugger_utils.close_debugger(self)
debugger_utils.delete_function(self, utils)
db_utils.disconnect_database(self, self.server_id, self.db_id)
