def setNoiseProfileCallback(self, req): res = AudioProcessingSetNoiseProfileSrvResponse() #-------------------------Check with database-------------------------# serv_db_topic = rospy.get_param("rapp_mysql_wrapper_user_fetch_data_topic") authentication_service = rospy.ServiceProxy(serv_db_topic, fetchDataSrv) req_db = fetchDataSrv() req_db.req_cols=["username"] entry1=["username", req.user] req_db.where_data=[StringArrayMsg(s=entry1)] resp = authentication_service(req_db.req_cols, req_db.where_data) if resp.success.data != True or len(resp.res_data) == 0: res.success = "false" res.error = "Non authenticated user" return res #-------------------------set noise profile-------------------------# ret = self._set_noise_profile_module.setNoise_profile(\ req.user,\ req.noise_audio_file,\ req.audio_file_type) if ret == 'true': res.success = ret res.error = '' else: res.success = 'false' res.error = ret return res
def setNoiseProfile(self, req): res = AudioProcessingSetNoiseProfileSrvResponse() #-------------------------Check with database-------------------------# authentication_service = rospy.ServiceProxy(self.serv_db_topic, fetchDataSrv) req_db = fetchDataSrv() req_db.req_cols=["username"] entry1=["username", req.user] req_db.where_data=[StringArrayMsg(s=entry1)] resp = authentication_service(req_db.req_cols, req_db.where_data) if resp.success.data != True or len(resp.res_data) == 0: res.success = "false" res.error = "Non authenticated user" return res #-------------------------set noise profile-------------------------# ret = self.set_noise_profile_module.setNoise_profile(\ req.user,\ req.noise_audio_file,\ req.audio_file_type) if ret == 'true': res.success = ret res.error = '' else: res.success = 'false' res.error = ret return res
def testNullInputError(self): serv_topic = rospy.get_param('rapp_mysql_wrapper_robot_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_robot_read_data_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=[] entry1=[] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Wrong Query Input Format, check for empty required columns list or wrong/incomplete Query data format") self.assertFalse(response.success.data)
def testNullInputError(self): serv_topic = rospy.get_param('rapp_mysql_wrapper_robot_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_robot_read_data_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=[] entry1=[] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"IndexError: list index out of range") self.assertFalse(response.success.data)
def testNullInputError(self): serv_topic = rospy.get_param( 'rapp_mysql_wrapper_robot_fetch_data_topic') if (not serv_topic): rospy.logerror("mysql_wrapper_robot_read_data_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = [] entry1 = [] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "IndexError: list index out of range") self.assertFalse(response.success.data)
def testNullInputError(self): serv_topic = rospy.get_param( 'rapp_mysql_wrapper_robot_fetch_data_topic') if (not serv_topic): rospy.logerror("mysql_wrapper_robot_read_data_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = [] entry1 = [] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual( response.trace[0], "Wrong Query Input Format, check for empty required columns list or wrong/incomplete Query data format" ) self.assertFalse(response.success.data)
def speechRecognitionBatch(self, req): total_res = SpeechRecognitionSphinx4TotalSrvResponse() #-------------------------Check with database-------------------------# if self.use_db_authentication == True: req_db = fetchDataSrv() req_db.req_cols = ["username"] entry1 = ["username", req.user] req_db.where_data = [StringArrayMsg(s=entry1)] resp = self.authentication_service(req_db.req_cols, req_db.where_data) if resp.success.data != True or len(resp.res_data) == 0: total_res.error = "Non authenticated user" return total_res conf_req = SpeechRecognitionSphinx4ConfigureSrvRequest() spee_req = SpeechRecognitionSphinx4SrvRequest() conf_req.language = req.language conf_req.words = req.words conf_req.grammar = req.grammar conf_req.sentences = req.sentences conf_res = SpeechRecognitionSphinx4ConfigureSrvResponse() conf_res = self.configureSpeechRecognition(conf_req) total_res.error = conf_res.error if conf_res.error != '': total_res.error = total_res.error + '\n' + conf_res.error return total_res spee_req.path = req.path spee_req.audio_source = req.audio_source spee_req.user = req.user spee_res = self.speechRecognition(spee_req) total_res.words = spee_res.words total_res.error = spee_res.error return total_res
def speechRecognitionBatch(self, req): total_res = SpeechRecognitionSphinx4TotalSrvResponse() #-------------------------Check with database-------------------------# if self.use_db_authentication == True: req_db = fetchDataSrv() req_db.req_cols=["username"] entry1=["username", req.user] req_db.where_data=[StringArrayMsg(s=entry1)] resp = self.authentication_service(req_db.req_cols, req_db.where_data) if resp.success.data != True or len(resp.res_data) == 0: total_res.error = "Non authenticated user" return total_res conf_req = SpeechRecognitionSphinx4ConfigureSrvRequest() spee_req = SpeechRecognitionSphinx4SrvRequest() conf_req.language = req.language conf_req.words = req.words conf_req.grammar = req.grammar conf_req.sentences = req.sentences conf_res = SpeechRecognitionSphinx4ConfigureSrvResponse() conf_res = self.configureSpeechRecognition(conf_req) total_res.error = conf_res.error if conf_res.error != '': total_res.error = total_res.error + '\n' + conf_res.error return total_res spee_req.path = req.path spee_req.audio_source = req.audio_source spee_req.user = req.user spee_res = self.speechRecognition(spee_req) total_res.words = spee_res.words total_res.error = spee_res.error return total_res
def testTblRappWriteReadDeleteCheck(self): #Write serv_topic = rospy.get_param( 'rapp_mysql_wrapper_rapp_write_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_rapp_write_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, writeDataSrv) req = writeDataSrv() req.req_cols = [ "rapp", "version", "arch", "lang", "owner", "directory", "enabled", "timestamp" ] entry1 = StringArrayMsg() entry1 = [ "'testingDB1'", "'1.01'", "'15'", "'1'", "'25'", "'testingDB1'", "'0'", "'555'" ] entry2 = StringArrayMsg() entry2 = [ "'testingDB2'", "'1.01'", "'15'", "'1'", "'25'", "'testingDB1'", "'0'", "'555'" ] req.req_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)] response = db_service(req.req_cols, req.req_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Read what was written serv_topic = rospy.get_param( 'rapp_mysql_wrapper_rapp_fetch_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_rapp_fetch_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["rapp", "directory"] entry1 = ["directory", "testingDB1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0], "testingDB1") self.assertEqual(response.res_data[1].s[0], "testingDB2") #Update written serv_topic = rospy.get_param( 'rapp_mysql_wrapper_rapp_update_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_rapp_update_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, updateDataSrv) req = updateDataSrv() req.set_cols = ["rapp='testingDB3'"] entry1 = ["rapp", "testingDB2"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.set_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Read again serv_topic = rospy.get_param( 'rapp_mysql_wrapper_rapp_fetch_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_rapp_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["rapp", "directory"] entry1 = ["directory", "testingDB1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0], "testingDB1") self.assertEqual(response.res_data[1].s[0], "testingDB3") #Delete updated serv_topic = rospy.get_param( 'rapp_mysql_wrapper_rapp_delete_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_rapp_delete_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv) req = deleteDataSrv() entry1 = ["directory", "testingDB1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Check if it was deleted serv_topic = rospy.get_param( 'rapp_mysql_wrapper_rapp_fetch_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_rapp_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["rapp", "directory"] entry1 = ["directory", "testingDB1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertTrue((len(response.res_data) < 1))
def speech_to_text(self, file_path, user, audio_file_type, language): # Check the user serv_db_topic = rospy.get_param("rapp_mysql_wrapper_user_fetch_data_topic") authentication_service = rospy.ServiceProxy(serv_db_topic, fetchDataSrv) req_db = fetchDataSrv() req_db.req_cols=["username"] entry1=["username", user] req_db.where_data=[StringArrayMsg(s=entry1)] resp = authentication_service(req_db.req_cols, req_db.where_data) if resp.success.data != True or len(resp.res_data) == 0: raise RappError("Non authenticated user") # Check if file exists if not os.path.isfile(file_path): raise RappError("Error: file " + file_path + ' not found') # Check if file is flac. If not convert it new_audio = file_path audio_trans_topic = rospy.get_param("rapp_audio_processing_transform_audio_topic") audio_transform_srv = rospy.ServiceProxy( audio_trans_topic, AudioProcessingTransformAudioSrv ) cleanup = [] transform_req = AudioProcessingTransformAudioSrvRequest() transform_req.source_type = audio_file_type transform_req.source_name = new_audio transform_req.target_type = 'wav' new_audio += '.wav' transform_req.target_name = new_audio transform_req.target_channels = 1 transform_req.target_rate = 16000 trans_response = audio_transform_srv( transform_req ) if trans_response.error != 'success': raise RappError( trans_response.error ) cleanup.append(new_audio) # Denoise if necessary prev_audio_file = new_audio next_audio_file = prev_audio_file if audio_file_type in ['nao_ogg', 'nao_wav_1_ch', 'nao_wav_4_ch']: denoise_topic = rospy.get_param("rapp_audio_processing_denoise_topic") energy_denoise_topic = \ rospy.get_param("rapp_audio_processing_energy_denoise_topic") denoise_service = rospy.ServiceProxy(\ denoise_topic, AudioProcessingDenoiseSrv) energy_denoise_service = rospy.ServiceProxy(\ energy_denoise_topic, AudioProcessingDenoiseSrv) manipulation = {} manipulation['sox_transform'] = False manipulation['sox_denoising'] = False manipulation['sox_channels_and_rate'] = False if audio_file_type == "headset": pass elif audio_file_type == "nao_ogg": manipulation['sox_transform'] = True manipulation['sox_denoising'] = True manipulation['sox_denoising_scale'] = 0.15 elif audio_file_type == "nao_wav_4_ch": manipulation['sox_channels_and_rate'] = True manipulation['sox_denoising'] = True manipulation['sox_denoising_scale'] = 0.15 elif audio_file_type == "nao_wav_1_ch": manipulation['sox_denoising'] = True manipulation['sox_denoising_scale'] = 0.15 manipulation['detect_silence'] = True manipulation['detect_silence_threshold'] = 0.25 # Check if sox_transform is needed if manipulation['sox_transform'] == True: next_audio_file += "_transformed.wav" command = "sox " + prev_audio_file + " " + next_audio_file com_res = os.system(command) if com_res != 0: raise RappError("Error: sox malfunctioned") cleanup.append(next_audio_file) prev_audio_file = next_audio_file if manipulation['sox_channels_and_rate'] == True: next_audio_file += "_mono16k.wav" command = "sox " + prev_audio_file + " -r 16000 -c 1 " + next_audio_file com_res = os.system(command) if com_res != 0: raise RappError("Error: sox malfunctioned") cleanup.append(next_audio_file) prev_audio_file = next_audio_file if manipulation['sox_denoising'] == True: next_audio_file = prev_audio_file + "_denoised.wav" den_request = AudioProcessingDenoiseSrvRequest() den_request.audio_file = prev_audio_file den_request.denoised_audio_file = next_audio_file den_request.audio_type = audio_file_type den_request.user = user den_request.scale = manipulation['sox_denoising_scale'] den_response = denoise_service(den_request) if den_response.success != "true": raise RappError("Error:" + den_response.success) cleanup.append(next_audio_file) prev_audio_file = next_audio_file # must implement a fallback function to clear redundant files # Transform to flac transform_req = AudioProcessingTransformAudioSrvRequest() transform_req.source_type = 'headset' transform_req.source_name = new_audio transform_req.target_type = 'flac' newer_audio = new_audio + '.flac' transform_req.target_name = newer_audio transform_req.target_channels = 1 transform_req.target_rate = 16000 trans_response = audio_transform_srv( transform_req ) cleanup.append(newer_audio) if trans_response.error != 'success': raise RappError( trans_response.error ) # Open the file with open(newer_audio, "r") as f: speech = f.read() url = "www.google.com" # Fix language if language == 'en': language = "en-US" elif language == 'gr': language = 'el' #NOTE - Thats a general usage key. They may disable it in the future. key = "AIzaSyBOti4mM-6x9WDnZIjIeyEU21OpBXqWBgw" path = "/speech-api/v2/recognize?lang=" + language + "&key=" + key headers = { "Content-type": "audio/x-flac; rate=22050" }; params = {"xjerr": "1", "client": "chromium"} conn = httplib.HTTPSConnection(url) conn.request("POST", path, speech, headers) response = conn.getresponse() data = response.read() initial_data = data # Google returns one empty result for some reason here. Removing it.. index = data.find("}") data = data[index + 1:] if data == '\n': # Returned nothing.. something went wrong data = initial_data jsdata = json.loads(data) # Remove the flac if needed for f in cleanup: command = 'rm -f ' + f if os.system(command): raise RappError("Error: Removal of temporary file malfunctioned") return jsdata
def testTblUserWriteReadDeleteCheck(self): #Write serv_topic = rospy.get_param( 'rapp_mysql_wrapper_user_write_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_user_write_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, writeDataSrv) req = writeDataSrv() req.req_cols = [ "name", "email", "pwd", "activated", "language", "ontology_alias" ] #req.req_cols=["idsd","macddr", "model","owner", "timestamp"] entry1 = StringArrayMsg() entry1 = [ "'rappMysqlTestTemp1'", "'*****@*****.**'", "'rappMysqlTestTemp1TestPass'", "'Y'", "'el'", "NULL" ] entry2 = StringArrayMsg() entry2 = [ "'rappMysqlTestTemp2'", "'*****@*****.**'", "'rappMysqlTestTemp2TestPass'", "'Y'", "'el'", "NULL" ] req.req_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)] response = db_service(req.req_cols, req.req_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Read what was written serv_topic = rospy.get_param( 'rapp_mysql_wrapper_user_fetch_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_user_fetch_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["name", "email"] entry1 = ["name", "rappMysqlTestTemp1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0], "rappMysqlTestTemp1") #self.assertEqual(response.res_data[1].s[0],"*****@*****.**") #Update written serv_topic = rospy.get_param( 'rapp_mysql_wrapper_user_update_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_user_update_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, updateDataSrv) req = updateDataSrv() req.set_cols = ["name='rappMysqlTestTemp1'"] entry1 = ["name", "rappMysqlTestTemp2"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.set_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Read again serv_topic = rospy.get_param( 'rapp_mysql_wrapper_user_fetch_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_user_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["name", "email"] entry1 = ["name", "rappMysqlTestTemp1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0], "rappMysqlTestTemp1") self.assertEqual(response.res_data[1].s[0], "rappMysqlTestTemp1") #Delete updated serv_topic = rospy.get_param( 'rapp_mysql_wrapper_user_delete_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_user_delete_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv) req = deleteDataSrv() entry1 = ["name", "rappMysqlTestTemp1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Check if it was deleted serv_topic = rospy.get_param( 'rapp_mysql_wrapper_user_fetch_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_user_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["name", "email"] entry1 = ["name", "rappMysqlTestTemp1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertTrue((len(response.res_data) < 1))
def testTblModelWriteReadDeleteCheck(self): #Write serv_topic = rospy.get_param('rapp_mysql_wrapper_model_write_data_topic') if(not serv_topic): rospy.logerror("rapp_mysql_wrapper_model_write_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, writeDataSrv) req = writeDataSrv() req.req_cols=["model_str","manufacturer","version","arch","os","picture"] entry1=StringArrayMsg() entry1=["'testingDB1'","'testingDB1'","'10.1'","'test'","'test'","'test'"] entry2=StringArrayMsg() entry2=["'testingDB2'","'testingDB1'","'10.1'","'test'","'test'","'test'"] req.req_data=[StringArrayMsg(s=entry1),StringArrayMsg(s=entry2)] response = db_service(req.req_cols,req.req_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Read what was written serv_topic = rospy.get_param('rapp_mysql_wrapper_model_fetch_data_topic') if(not serv_topic): rospy.logerror("rapp_mysql_wrapper_model_fetch_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["model_str","manufacturer"] entry1=["manufacturer","testingDB1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0],"testingDB1") self.assertEqual(response.res_data[1].s[0],"testingDB2") #Update written serv_topic = rospy.get_param('rapp_mysql_wrapper_model_update_data_topic') if(not serv_topic): rospy.logerror("rapp_mysql_wrapper_model_update_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, updateDataSrv) req = updateDataSrv() req.set_cols=["model_str='testingDB3'"] entry1=["model_str","testingDB2"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.set_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Read again serv_topic = rospy.get_param('rapp_mysql_wrapper_model_fetch_data_topic') if(not serv_topic): rospy.logerror("rapp_mysql_wrapper_model_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["model_str","manufacturer"] entry1=["manufacturer","testingDB1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[1],"testingDB1") self.assertEqual(response.res_data[1].s[1],"testingDB1") #Delete updated serv_topic = rospy.get_param('rapp_mysql_wrapper_model_delete_data_topic') if(not serv_topic): rospy.logerror("rapp_mysql_wrapper_model_delete_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv) req = deleteDataSrv() entry1=["manufacturer","testingDB1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Check if it was deleted serv_topic = rospy.get_param('rapp_mysql_wrapper_model_fetch_data_topic') if(not serv_topic): rospy.logerror("rapp_mysql_wrapper_model_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["model_str","manufacturer"] entry1=["model_str","testingDB1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertTrue((len(response.res_data)<1))
def testTblRappWriteReadDeleteCheck(self): #Write serv_topic = rospy.get_param('rapp_mysql_wrapper_rapp_write_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_rapp_write_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, writeDataSrv) req = writeDataSrv() req.req_cols=["rapp","version","arch","lang","owner","directory","enabled","timestamp"] entry1=StringArrayMsg() entry1=["'testingDB1'","'1.01'","'15'","'1'","'25'","'testingDB1'","'0'","'555'"] entry2=StringArrayMsg() entry2=["'testingDB2'","'1.01'","'15'","'1'","'25'","'testingDB1'","'0'","'555'"] req.req_data=[StringArrayMsg(s=entry1),StringArrayMsg(s=entry2)] response = db_service(req.req_cols,req.req_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Read what was written serv_topic = rospy.get_param('rapp_mysql_wrapper_rapp_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_rapp_fetch_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["rapp","directory"] entry1=["directory","testingDB1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0],"testingDB1") self.assertEqual(response.res_data[1].s[0],"testingDB2") #Update written serv_topic = rospy.get_param('rapp_mysql_wrapper_rapp_update_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_rapp_update_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, updateDataSrv) req = updateDataSrv() req.set_cols=["rapp='testingDB3'"] entry1=["rapp","testingDB2"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.set_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Read again serv_topic = rospy.get_param('rapp_mysql_wrapper_rapp_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_rapp_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["rapp","directory"] entry1=["directory","testingDB1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0],"testingDB1") self.assertEqual(response.res_data[1].s[0],"testingDB3") #Delete updated serv_topic = rospy.get_param('rapp_mysql_wrapper_rapp_delete_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_rapp_delete_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv) req = deleteDataSrv() entry1=["directory","testingDB1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Check if it was deleted serv_topic = rospy.get_param('rapp_mysql_wrapper_rapp_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_rapp_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["rapp","directory"] entry1=["directory","testingDB1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertTrue((len(response.res_data)<1))
def testTblUserWriteReadDeleteCheck(self): #Write serv_topic = rospy.get_param('rapp_mysql_wrapper_user_write_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_user_write_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, writeDataSrv) req = writeDataSrv() req.req_cols=["name","email","pwd","activated","language","ontology_alias"] #req.req_cols=["idsd","macddr", "model","owner", "timestamp"] entry1=StringArrayMsg() entry1=["'rappMysqlTestTemp1'","'*****@*****.**'","'rappMysqlTestTemp1TestPass'","'Y'","'el'","NULL"] entry2=StringArrayMsg() entry2=["'rappMysqlTestTemp2'","'*****@*****.**'","'rappMysqlTestTemp2TestPass'","'Y'","'el'","NULL"] req.req_data=[StringArrayMsg(s=entry1),StringArrayMsg(s=entry2)] response = db_service(req.req_cols,req.req_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Read what was written serv_topic = rospy.get_param('rapp_mysql_wrapper_user_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_user_fetch_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["name","email"] entry1=["name","rappMysqlTestTemp1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0],"rappMysqlTestTemp1") #self.assertEqual(response.res_data[1].s[0],"*****@*****.**") #Update written serv_topic = rospy.get_param('rapp_mysql_wrapper_user_update_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_user_update_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, updateDataSrv) req = updateDataSrv() req.set_cols=["name='rappMysqlTestTemp1'"] entry1=["name","rappMysqlTestTemp2"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.set_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Read again serv_topic = rospy.get_param('rapp_mysql_wrapper_user_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_user_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["name","email"] entry1=["name","rappMysqlTestTemp1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0],"rappMysqlTestTemp1") self.assertEqual(response.res_data[1].s[0],"rappMysqlTestTemp1") #Delete updated serv_topic = rospy.get_param('rapp_mysql_wrapper_user_delete_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_user_delete_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv) req = deleteDataSrv() entry1=["name","rappMysqlTestTemp1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Check if it was deleted serv_topic = rospy.get_param('rapp_mysql_wrapper_user_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_user_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["name","email"] entry1=["name","rappMysqlTestTemp1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertTrue((len(response.res_data)<1))
def testTblRobotWriteReadDeleteCheck(self): #Write serv_topic = rospy.get_param('rapp_mysql_wrapper_robot_write_data_topic') if(not serv_topic): rospy.logerror("rapp_mysql_wrapper_robot_write_data_topic NOT FOUND ERROR") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, writeDataSrv) req = writeDataSrv() req.req_cols=[]#[String(data="model_str"),String(data="manufacturer"),String(data="version"),String(data="arch"),String(data="os"),String(data="picture")] #req.req_cols=[String("id"),String("macddr"), String("model"),String("owner"), String("timestamp")] req.req_cols=["macddr", "model","owner", "timestamp"] entry1=StringArrayMsg() entry1=["'1800000'", "'1'","'25'", "'2014-11-23 09:04:13'"] entry2=StringArrayMsg() entry2=["'1900000'", "'1'","'25'", "'2014-11-23 07:04:13'"] req.req_data=[StringArrayMsg(s=entry1),StringArrayMsg(s=entry2)] response = db_service(req.req_cols,req.req_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Read what was written serv_topic = rospy.get_param('rapp_mysql_wrapper_robot_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_robot_read_data_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["macddr"] entry1=["macddr","1800000"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0],"1800000") #self.assertEqual(response.res_data[1].s[0].data,"extreme3") #Update written serv_topic = rospy.get_param('rapp_mysql_wrapper_robot_update_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_robot_update_data_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, updateDataSrv) req = updateDataSrv() req.set_cols=["timestamp='2014-11-23 09:04:13'"] entry1=["macddr",'1900000'] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.set_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Read again serv_topic = rospy.get_param('rapp_mysql_wrapper_robot_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_robot_fetch_data_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["macddr","model"] entry1=["timestamp","2014-11-23 09:04:13"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0],"1800000") self.assertEqual(response.res_data[1].s[0],"1900000") #Delete updated serv_topic = rospy.get_param('rapp_mysql_wrapper_robot_delete_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_robot_delete_data_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv) req = deleteDataSrv() entry1=["timestamp","2014-11-23 09:04:13"] entry2=["model","1"] req.where_data=[StringArrayMsg(s=entry1),StringArrayMsg(s=entry2)] response = db_service(req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Check if it was deleted serv_topic = rospy.get_param('rapp_mysql_wrapper_robot_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_robot_write_delete_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["macddr","model"] entry1=["timestamp","2014-11-23 09:04:13"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertTrue((len(response.res_data)<1))
def testTblRobotWriteReadDeleteCheck(self): #Write serv_topic = rospy.get_param( 'rapp_mysql_wrapper_robot_write_data_topic') if (not serv_topic): rospy.logerror( "rapp_mysql_wrapper_robot_write_data_topic NOT FOUND ERROR") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, writeDataSrv) req = writeDataSrv() req.req_cols = [ ] #[String(data="model_str"),String(data="manufacturer"),String(data="version"),String(data="arch"),String(data="os"),String(data="picture")] #req.req_cols=[String("id"),String("macddr"), String("model"),String("owner"), String("timestamp")] req.req_cols = ["macddr", "model", "owner", "timestamp"] entry1 = StringArrayMsg() entry1 = ["'1800000'", "'1'", "'25'", "'2014-11-23 09:04:13'"] entry2 = StringArrayMsg() entry2 = ["'1900000'", "'1'", "'25'", "'2014-11-23 07:04:13'"] req.req_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)] response = db_service(req.req_cols, req.req_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Read what was written serv_topic = rospy.get_param( 'rapp_mysql_wrapper_robot_fetch_data_topic') if (not serv_topic): rospy.logerror("mysql_wrapper_robot_read_data_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["macddr"] entry1 = ["macddr", "1800000"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0], "1800000") #self.assertEqual(response.res_data[1].s[0].data,"extreme3") #Update written serv_topic = rospy.get_param( 'rapp_mysql_wrapper_robot_update_data_topic') if (not serv_topic): rospy.logerror("mysql_wrapper_robot_update_data_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, updateDataSrv) req = updateDataSrv() req.set_cols = ["timestamp='2014-11-23 09:04:13'"] entry1 = ["macddr", '1900000'] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.set_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Read again serv_topic = rospy.get_param( 'rapp_mysql_wrapper_robot_fetch_data_topic') if (not serv_topic): rospy.logerror("mysql_wrapper_robot_fetch_data_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["macddr", "model"] entry1 = ["timestamp", "2014-11-23 09:04:13"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0], "1800000") self.assertEqual(response.res_data[1].s[0], "1900000") #Delete updated serv_topic = rospy.get_param( 'rapp_mysql_wrapper_robot_delete_data_topic') if (not serv_topic): rospy.logerror("mysql_wrapper_robot_delete_data_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv) req = deleteDataSrv() entry1 = ["timestamp", "2014-11-23 09:04:13"] entry2 = ["model", "1"] req.where_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)] response = db_service(req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Check if it was deleted serv_topic = rospy.get_param( 'rapp_mysql_wrapper_robot_fetch_data_topic') if (not serv_topic): rospy.logerror("mysql_wrapper_robot_write_delete_topic") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["macddr", "model"] entry1 = ["timestamp", "2014-11-23 09:04:13"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertTrue((len(response.res_data) < 1))
def testTblUserWriteReadDeleteCheck(self): #Write serv_topic = rospy.get_param('rapp_mysql_wrapper_user_write_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_user_write_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, writeDataSrv) req = writeDataSrv() req.req_cols=["username","firstname","lastname","email","email_id","ontology_alias","pwd","usrgroup","created","accessed","enabled","activation"] #req.req_cols=["idsd","macddr", "model","owner", "timestamp"] entry1=StringArrayMsg() entry1=["'testingDB1'","'testingDB1'","'testingDB1'","'test@test'","NULL","NULL","'86'","'0'","'2014-15-15 18:01:34'","'0000-00-00 00:00:00'","'1'","'555'"] entry2=StringArrayMsg() entry2=["'testingDB2'","'testingDB2'","'testingDB1'","'test@test'","NULL","NULL","'86'","'0'","'2014-15-15 18:01:34'","'0000-00-00 00:00:00'","'1'","'555'"] req.req_data=[StringArrayMsg(s=entry1),StringArrayMsg(s=entry2)] response = db_service(req.req_cols,req.req_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Read what was written serv_topic = rospy.get_param('rapp_mysql_wrapper_user_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_user_fetch_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["firstname","lastname"] entry1=["lastname","testingDB1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0],"testingDB1") self.assertEqual(response.res_data[1].s[0],"testingDB2") #Update written serv_topic = rospy.get_param('rapp_mysql_wrapper_user_update_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_user_update_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, updateDataSrv) req = updateDataSrv() req.set_cols=["firstname='testingDB1'"] entry1=["firstname","testingDB2"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.set_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Read again serv_topic = rospy.get_param('rapp_mysql_wrapper_user_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_user_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["firstname","lastname"] entry1=["firstname","testingDB1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0],"testingDB1") self.assertEqual(response.res_data[1].s[0],"testingDB1") #Delete updated serv_topic = rospy.get_param('rapp_mysql_wrapper_user_delete_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_user_delete_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv) req = deleteDataSrv() entry1=["firstname","testingDB1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) #Check if it was deleted serv_topic = rospy.get_param('rapp_mysql_wrapper_user_fetch_data_topic') if(not serv_topic): rospy.logerror("mysql_wrapper_user_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols=["firstname","lastname"] entry1=["firstname","testingDB1"] req.where_data=[StringArrayMsg(s=entry1)] response = db_service(req.req_cols,req.where_data) self.assertEqual(response.trace[0],"Success") self.assertTrue(response.success.data) self.assertTrue((len(response.res_data)<1))
def testTblModelWriteReadDeleteCheck(self): #Write serv_topic = rospy.get_param( 'rapp_mysql_wrapper_model_write_data_topic') if (not serv_topic): rospy.logerror( "rapp_mysql_wrapper_model_write_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, writeDataSrv) req = writeDataSrv() req.req_cols = [ "model_str", "manufacturer", "version", "arch", "os", "picture" ] entry1 = StringArrayMsg() entry1 = [ "'testingDB1'", "'testingDB1'", "'10.1'", "'test'", "'test'", "'test'" ] entry2 = StringArrayMsg() entry2 = [ "'testingDB2'", "'testingDB1'", "'10.1'", "'test'", "'test'", "'test'" ] req.req_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)] response = db_service(req.req_cols, req.req_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Read what was written serv_topic = rospy.get_param( 'rapp_mysql_wrapper_model_fetch_data_topic') if (not serv_topic): rospy.logerror( "rapp_mysql_wrapper_model_fetch_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["model_str", "manufacturer"] entry1 = ["manufacturer", "testingDB1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0], "testingDB1") self.assertEqual(response.res_data[1].s[0], "testingDB2") #Update written serv_topic = rospy.get_param( 'rapp_mysql_wrapper_model_update_data_topic') if (not serv_topic): rospy.logerror( "rapp_mysql_wrapper_model_update_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, updateDataSrv) req = updateDataSrv() req.set_cols = ["model_str='testingDB3'"] entry1 = ["model_str", "testingDB2"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.set_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Read again serv_topic = rospy.get_param( 'rapp_mysql_wrapper_model_fetch_data_topic') if (not serv_topic): rospy.logerror( "rapp_mysql_wrapper_model_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["model_str", "manufacturer"] entry1 = ["manufacturer", "testingDB1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[1], "testingDB1") self.assertEqual(response.res_data[1].s[1], "testingDB1") #Delete updated serv_topic = rospy.get_param( 'rapp_mysql_wrapper_model_delete_data_topic') if (not serv_topic): rospy.logerror( "rapp_mysql_wrapper_model_delete_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv) req = deleteDataSrv() entry1 = ["manufacturer", "testingDB1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Check if it was deleted serv_topic = rospy.get_param( 'rapp_mysql_wrapper_model_fetch_data_topic') if (not serv_topic): rospy.logerror( "rapp_mysql_wrapper_model_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["model_str", "manufacturer"] entry1 = ["model_str", "testingDB1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertTrue((len(response.res_data) < 1))
def testTblUserWriteReadDeleteCheck(self): #Write serv_topic = rospy.get_param( 'rapp_mysql_wrapper_user_write_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_user_write_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, writeDataSrv) req = writeDataSrv() req.req_cols = [ "username", "firstname", "lastname", "email", "email_id", "ontology_alias", "pwd", "usrgroup", "created", "accessed", "enabled", "activation" ] #req.req_cols=["idsd","macddr", "model","owner", "timestamp"] entry1 = StringArrayMsg() entry1 = [ "'testingDB1'", "'testingDB1'", "'testingDB1'", "'test@test'", "NULL", "NULL", "'86'", "'0'", "'2014-15-15 18:01:34'", "'0000-00-00 00:00:00'", "'1'", "'555'" ] entry2 = StringArrayMsg() entry2 = [ "'testingDB2'", "'testingDB2'", "'testingDB1'", "'test@test'", "NULL", "NULL", "'86'", "'0'", "'2014-15-15 18:01:34'", "'0000-00-00 00:00:00'", "'1'", "'555'" ] req.req_data = [StringArrayMsg(s=entry1), StringArrayMsg(s=entry2)] response = db_service(req.req_cols, req.req_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Read what was written serv_topic = rospy.get_param( 'rapp_mysql_wrapper_user_fetch_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_user_fetch_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["firstname", "lastname"] entry1 = ["lastname", "testingDB1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0], "testingDB1") self.assertEqual(response.res_data[1].s[0], "testingDB2") #Update written serv_topic = rospy.get_param( 'rapp_mysql_wrapper_user_update_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_user_update_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, updateDataSrv) req = updateDataSrv() req.set_cols = ["firstname='testingDB1'"] entry1 = ["firstname", "testingDB2"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.set_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Read again serv_topic = rospy.get_param( 'rapp_mysql_wrapper_user_fetch_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_user_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["firstname", "lastname"] entry1 = ["firstname", "testingDB1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertEqual(response.res_data[0].s[0], "testingDB1") self.assertEqual(response.res_data[1].s[0], "testingDB1") #Delete updated serv_topic = rospy.get_param( 'rapp_mysql_wrapper_user_delete_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_user_delete_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, deleteDataSrv) req = deleteDataSrv() entry1 = ["firstname", "testingDB1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) #Check if it was deleted serv_topic = rospy.get_param( 'rapp_mysql_wrapper_user_fetch_data_topic') if (not serv_topic): rospy.logerror( "mysql_wrapper_user_read_data topic param not found") rospy.wait_for_service(serv_topic) db_service = rospy.ServiceProxy(serv_topic, fetchDataSrv) req = fetchDataSrv() req.req_cols = ["firstname", "lastname"] entry1 = ["firstname", "testingDB1"] req.where_data = [StringArrayMsg(s=entry1)] response = db_service(req.req_cols, req.where_data) self.assertEqual(response.trace[0], "Success") self.assertTrue(response.success.data) self.assertTrue((len(response.res_data) < 1))