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)