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))
