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 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 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.")
db_user = self.server["username"]
data = {
"name":
db_user,
"um_options": [],
"umoptions": [{
"umoption": "user",
"umvalue": self.server["username"]
}, {
"umoption": "password",
"umvalue": self.server["db_password"]
}]
}
response = self.tester.post(
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),
content_type='html/json')
self.assertEquals(response.status_code, 200)
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.")
if self.is_positive_test:
if self.is_list:
response = ft_utils.api_delete(self)
else:
response = ft_utils.api_delete(self, self.ft_id)
# Assert response
utils.assert_status_code(self, response)
def runTest(self):
"""This function will delete user mapping present under test
database. """
db_con = database_utils.connect_database(self, utils.SERVER_GROUP,
self.server_id, self.db_id)
if not db_con["info"] == "Database connected.":
raise Exception("Could not connect to database.")
fdw_response = fdw_utils.verify_fdw(self.server, self.db_name,
self.fdw_name)
if not fdw_response:
raise Exception("Could not find FDW.")
fsrv_response = fsrv_utils.verify_fsrv(self.server, self.db_name,
self.fsrv_name)
if not fsrv_response:
raise Exception("Could not find FSRV.")
um_response = um_utils.verify_user_mapping(self.server, self.db_name,
self.fsrv_name)
if not um_response:
raise Exception("Could not find user mapping.")
delete_response = self.tester.delete(
self.url + str(utils.SERVER_GROUP) + '/' + str(self.server_id) +
'/' + str(self.db_id) + '/' + str(self.fdw_id) + '/' +
str(self.fsrv_id) + '/' + str(self.um_id),
follow_redirects=True)
self.assertEquals(delete_response.status_code, 200)
def runTest(self):
"""This function will update foreign table under test database."""
db_con = database_utils.connect_database(self, utils.SERVER_GROUP,
self.server_id, self.db_id)
if not db_con["info"] == "Database connected.":
raise Exception("Could not connect to database.")
fsrv_response = fsrv_utils.verify_fsrv(self.server, self.db_name,
self.fsrv_name)
if not fsrv_response:
raise Exception("Could not find Foreign Server.")
ft_response = ft_utils.verify_foreign_table(self.server, self.db_name,
self.fsrv_name)
if not ft_response:
raise Exception("Could not find Foreign Table.")
self.data['id'] = self.ft_id
if self.is_positive_test:
response = ft_utils.api_put(self)
# Assert response
utils.assert_status_code(self, response)
else:
if self.mocking_required:
with patch(self.mock_data["function_name"],
side_effect=[eval(self.mock_data["return_value"])]):
response = ft_utils.api_put(self)
# Assert response
utils.assert_status_code(self, response)
utils.assert_error_message(self, response)
def runTest(self):
"""This function will fetch foreign table msql 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:
self.data['oid'] = self.ft_id
if 'inherits' in self.data:
tid = table_utils.create_table(self.server, self.db_name,
self.schema_name, 'toinherit',
"'CREATE TABLE %s.%s ()' "
"%(schema_name, table_name)")
self.data['inherits'] = [tid]
url_encode_data = self.data
response = ft_utils.api_get_msql(self, url_encode_data)
# Assert response
utils.assert_status_code(self, response)
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 runTest(self):
"""This function will update user mapping present under test
database"""
db_con = database_utils.connect_database(self, utils.SERVER_GROUP,
self.server_id, self.db_id)
if not db_con["info"] == "Database connected.":
raise Exception("Could not connect to database.")
fdw_response = fdw_utils.verify_fdw(self.server, self.db_name,
self.fdw_name)
if not fdw_response:
raise Exception("Could not find FDW.")
fsrv_response = fsrv_utils.verify_fsrv(self.server, self.db_name,
self.fsrv_name)
if not fsrv_response:
raise Exception("Could not find FSRV.")
um_response = um_utils.verify_user_mapping(self.server, self.db_name,
self.fsrv_name)
if not um_response:
raise Exception("Could not find user mapping.")
self.test_data["id"] = self.um_id
if self.is_positive_test:
put_response = self.update_user_mapping()
else:
if hasattr(self, "error_in_db"):
with patch(self.mock_data["function_name"],
side_effect=eval(self.mock_data["return_value"])):
put_response = self.update_user_mapping()
actual_response_code = put_response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEqual(actual_response_code, expected_response_code)
def 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 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.")
um_response = um_utils.verify_user_mapping(self.server, self.db_name,
self.fsrv_name)
if not um_response:
raise Exception("Could not find user mapping.")
data = {
"id": self.um_id,
"umoptions": {
"changed": [{
"umoption": "user",
"umvalue": "public"
}]
}
}
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) + '/' + str(self.um_id),
data=json.dumps(data),
follow_redirects=True)
self.assertEquals(put_response.status_code, 200)
def runTest(self):
"""This function will delete user mapping present under test
database. """
db_con = database_utils.connect_database(self, utils.SERVER_GROUP,
self.server_id, self.db_id)
if not db_con["info"] == "Database connected.":
raise Exception("Could not connect to database.")
fdw_response = fdw_utils.verify_fdw(self.server, self.db_name,
self.fdw_name)
if not fdw_response:
raise Exception("Could not find FDW.")
fsrv_response = fsrv_utils.verify_fsrv(self.server, self.db_name,
self.fsrv_name)
if not fsrv_response:
raise Exception("Could not find FSRV.")
um_response = um_utils.verify_user_mapping(self.server, self.db_name,
self.fsrv_name)
if not um_response:
raise Exception("Could not find user mapping.")
self.data = {'ids': [self.um_id]}
if self.is_positive_test:
delete_response = self.delete_multiple()
actual_response_code = delete_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 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 runTest(self):
"""This function will fetch foreign server and add user mappping
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.")
db_user = self.server["username"]
self.data = user_utils.get_um_data(db_user, self.server)
if self.is_positive_test:
response = self.create_user_mapping()
else:
if hasattr(self, "error_fsrv_id"):
self.fsrv_id = 99999
response = self.create_user_mapping()
if hasattr(self, "internal_server_error"):
return_value_object = eval(self.mock_data["return_value"])
with patch(self.mock_data["function_name"],
side_effect=[return_value_object]):
response = self.create_user_mapping()
if hasattr(self, "missing_parameter"):
del self.data['name']
response = self.create_user_mapping()
if hasattr(self, "error_in_db"):
return_value_object = eval(self.mock_data["return_value"])
with patch(self.mock_data["function_name"],
side_effect=[return_value_object]):
response = self.create_user_mapping()
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 add 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.")
data = {
"acl": [],
"basensp": self.schema_name,
"columns":
[
{
"attname": "ename",
"datatype": "text",
"coloptions": []
}
],
"constraints": [],
"ftoptions": [],
"inherits": [],
"ftsrvname": self.fsrv_name,
"name": "ft_%s" % (str(uuid.uuid4())[1:4]),
"owner": self.server["username"],
"relacl": [],
"seclabels": [],
"stracl": []
}
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 add 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_create(self)
# Assert response
utils.assert_status_code(self, response)
# Verify in backend
cross_check_res = ft_utils.verify_foreign_table(self.server,
self.db_name,
self.fsrv_name)
self.assertIsNotNone(cross_check_res, "Could not find the newly"
" created foreign table.")
else:
if self.mocking_required:
with patch(self.mock_data["function_name"],
side_effect=eval(self.mock_data["return_value"])):
response = ft_utils.api_create(self)
# Assert response
utils.assert_status_code(self, response)
utils.assert_error_message(self, response)
else:
del self.data['ftsrvname']
response = ft_utils.api_create(self)
# Assert response
utils.assert_status_code(self, response)
utils.assert_error_message(self, response)
def runTest(self):
"""This function will add 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.")
data = {
"acl": [],
"basensp": self.schema_name,
"columns": [
{
"attname": "ename",
"datatype": "text",
"coloptions": []
}
],
"constraints": [],
"ftoptions": [],
"inherits": [],
"ftsrvname": self.fsrv_name,
"name": self.ft_name,
"owner": self.server["username"],
"relacl": [],
"seclabels": [],
"stracl": []
}
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 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_list:
response = ft_utils.api_get(self, '')
else:
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 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.")
if self.is_positive_test:
if hasattr(self, "um_list"):
response = self.get_user_mapping_list()
else:
response = self.get_user_mapping()
else:
if hasattr(self, "error_fetching_um"):
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
if hasattr(self, "um_list"):
response = self.get_user_mapping_list()
else:
response = self.get_user_mapping()
if hasattr(self, "wrong_um_id"):
self.um_id = 99999
response = self.get_user_mapping()
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEquals(actual_response_code, expected_response_code)
def runTest(self):
"""This function will fetch user mapping present under test
database. """
db_con = database_utils.connect_database(self, utils.SERVER_GROUP,
self.server_id, self.db_id)
if not db_con["info"] == "Database connected.":
raise Exception("Could not connect to database.")
fdw_response = fdw_utils.verify_fdw(self.server, self.db_name,
self.fdw_name)
if not fdw_response:
raise Exception("Could not find FDW.")
fsrv_response = fsrv_utils.verify_fsrv(self.server, self.db_name,
self.fsrv_name)
if not fsrv_response:
raise Exception("Could not find FSRV.")
um_response = um_utils.verify_user_mapping(self.server, self.db_name,
self.fsrv_name)
if not um_response:
raise Exception("Could not find user mapping.")
if self.is_positive_test:
if hasattr(self, "node"):
response = self.get_user_mapping_node(self.um_id)
else:
response = self.get_user_mapping_node("")
else:
if hasattr(self, "internal_server_error"):
with patch(self.mock_data["function_name"],
return_value=eval(self.mock_data["return_value"])):
if hasattr(self, "node"):
response = self.get_user_mapping_node(self.um_id)
else:
response = self.get_user_mapping_node("")
actual_response_code = response.status_code
expected_response_code = self.expected_data['status_code']
self.assertEquals(actual_response_code, expected_response_code)
