def blackbox_test(self): # Make sure no pre-existing campaign with campaign urn: # 'urn:campaign:ca:ucla:Mobilize:July:2011:Test' HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) # Complete testing on 241 testing xml for x in range(1,242): FILE_PATH = XML_PATH + '/xml' + str(x) + '.xml' self.arg_pass_in['xml'] = (pycurl.FORM_FILE, FILE_PATH) # Use zip(dict.keys(), dict.values()) # can convert dict into a list of tuples self.http.set_pass_in_with_file(zip(self.arg_pass_in.keys(), self.arg_pass_in.values())) # Need to upload a file, set flag to 1 # to change the type of HTTP request self.http.request(1) self.total_case = self.total_case + 1 # Print status print 'Processing Case ID {0}.\n{1}% to finish XML Schema Testing.'.format('XML'+str(self.total_case), self.total_case*100/TOTAL_CASE) print self.http.contents # check response if self.exp_result[x] == 'success': if (self.http.http_code != 200) or (self.http.cont_dict['result'] != 'success'): HTTP.write_err_report(self.err_report,\ 'XML'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ '{"result": "success"}') # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('XML'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'XML'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) # need to delete the campaign after writing the success report result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot delete existing campaign' sys.exit(1) else: # Need to check whether expected string is a substring of result print self.http.contents.find(self.exp_result[x]) if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_XML) or \ (self.http.contents.find(self.exp_result[x]) == -1): HTTP.write_err_report(self.err_report,\ 'XML'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.INVALID_XML+': '+self.exp_result[x]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('XML'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 # Although unexpected success, still need to delete the original campaign if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'): result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot delete existing campaign' sys.exit(1) else: HTTP.write_succ_report(self.succ_report,\ 'XML'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents)
def err_response_check(self, exp_result): # helper function to check invalid cases response if exp_result == gconst.AUTH_FAIL: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.AUTH_FAIL): HTTP.write_err_report(self.err_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.AUTH_FAIL+': '+gconst.ERROR[gconst.AUTH_FAIL]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('CC'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 # Unexpected 'success' create campaign, need to delete the wrong campaign if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'): result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot delete existing campaign' sys.exit(1) else: HTTP.write_succ_report(self.succ_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.CLT_TOO_LONG: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.CLT_TOO_LONG): HTTP.write_err_report(self.err_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.CLT_TOO_LONG+': '+gconst.ERROR[gconst.CLT_TOO_LONG]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('CC'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 # Unexpected 'success' create campaign, need to delete the wrong campaign if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'): result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot delete existing campaign' sys.exit(1) else: HTTP.write_succ_report(self.succ_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.INVALID_RUN_STATE: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_RUN_STATE): HTTP.write_err_report(self.err_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.INVALID_RUN_STATE+': '+gconst.ERROR[gconst.INVALID_RUN_STATE]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('CC'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 # Unexpected 'success' create campaign, need to delete the wrong campaign if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'): result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot delete existing campaign' sys.exit(1) else: HTTP.write_succ_report(self.succ_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.INVALID_PRI_STATE: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_PRI_STATE): HTTP.write_err_report(self.err_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.INVALID_PRI_STATE+': '+gconst.ERROR[gconst.INVALID_PRI_STATE]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('CC'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 # Unexpected 'success' create campaign, need to delete the wrong campaign if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'): result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot delete existing campaign' sys.exit(1) else: HTTP.write_succ_report(self.succ_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.INVALID_CLS_URN: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_CLS_URN): HTTP.write_err_report(self.err_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.INVALID_CLS_URN+': '+gconst.ERROR[gconst.INVALID_CLS_URN]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('CC'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 # Unexpected 'success' create campaign, need to delete the wrong campaign if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'): result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot delete existing campaign' sys.exit(1) else: HTTP.write_succ_report(self.succ_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.INVALID_XML: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_XML): HTTP.write_err_report(self.err_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.INVALID_XML+': '+gconst.ERROR[gconst.INVALID_XML]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('CC'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 # Unexpected 'success' create campaign, need to delete the wrong campaign if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'): result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot delete existing campaign' sys.exit(1) else: HTTP.write_succ_report(self.succ_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) # this is necessary, since we don't really have an invalid case for "description" # TODO: you may delete this condition when "description" has something invalid elif exp_result == 'v': if (self.http.http_code != 200) or (self.http.cont_dict['result'] != 'success'): HTTP.write_err_report(self.err_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ '{"result": "success"}') # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('CC'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) # need to delete the campaign after writing the success report result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot delete existing campaign' sys.exit(1) else: print >> sys.stderr, 'Error: Unexpected invalid test case' sys.exit(1)
def blackbox_test(self): # Should delete the old campaign first HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) # Combination of three kinds of test cases defined in README # Special cases for 'Missing Argument' of argument 'description' # Part I: Valid Case for a in self.valid_arg['auth_token']: self.arg_pass_in = {} self.arg_pass_in_msg = [] self.arg_pass_in['auth_token'] = a self.arg_pass_in_msg.append(self.valid_arg_msg['auth_token'][0]) for clt in self.valid_arg['client']: self.arg_pass_in['client'] = clt self.arg_pass_in_msg.append(self.valid_arg_msg['client'][self.valid_arg['client'].index(clt)]) for run in self.valid_arg['running_state']: self.arg_pass_in['running_state'] = run self.arg_pass_in_msg.append(self.valid_arg_msg['running_state'][self.valid_arg['running_state'].index(run)]) for pri in self.valid_arg['privacy_state']: self.arg_pass_in['privacy_state'] = pri self.arg_pass_in_msg.append(self.valid_arg_msg['privacy_state'][self.valid_arg['privacy_state'].index(pri)]) for cls in self.valid_arg['class_urn_list']: self.arg_pass_in['class_urn_list'] = cls self.arg_pass_in_msg.append(self.valid_arg_msg['class_urn_list'][self.valid_arg['class_urn_list'].index(cls)]) for xml in self.valid_arg['xml']: self.arg_pass_in['xml'] = xml self.arg_pass_in_msg.append(self.valid_arg_msg['xml'][self.valid_arg['xml'].index(xml)]) for des in self.valid_arg['description']: self.update_arg_pass_in('description', des, 0) self.arg_pass_in_msg.append(self.valid_arg_msg['description'][self.valid_arg['description'].index(des)]) # Determine the expected result exp_result = self.result_det(self.arg_pass_in_msg) # Use zip(dict.keys(), dict.values()) # can convert dict into a list of tuples self.http.set_pass_in_with_file(zip(self.arg_pass_in.keys(), self.arg_pass_in.values())) # Need to upload a file, set flag to 1 # to change the type of HTTP request self.http.request(1) self.total_case = self.total_case + 1 # Print status print 'Processing Case ID {0}.\n{1}% to finish Campaign Create API.'.format('CC'+str(self.total_case), \ self.total_case*100/TOTAL_CASE) # Check the response if exp_result == 'v': if (self.http.http_code != 200) or (self.http.cont_dict['result'] != 'success'): HTTP.write_err_report(self.err_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ '{"result": "success"}') # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('CC'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'CC'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) # need to delete the campaign after expected creation result = HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot delete existing campaign' sys.exit(1) else: print >> sys.stderr, 'Error: Invalid valid test case' sys.exit(1) # update arg_pass_in and arg_pass_in_msg self.update_arg_pass_in('description', des, 1) self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg del self.arg_pass_in['xml'] self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg del self.arg_pass_in['class_urn_list'] self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg del self.arg_pass_in['privacy_state'] self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg del self.arg_pass_in['running_state'] self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg del self.arg_pass_in['client'] self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg del self.arg_pass_in['auth_token'] self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) ######################################################################## ######################################################################## # Part II: Invalid case with one invalid argument # Here I reduce the number of test cases by only picking one combination # of valid case # pick each invalid argument once for arg_name in self.para_name_list: for arg in self.invalid_arg[arg_name]: # first keep all argument valid self.form_one_valid_arg() self.update_arg_pass_in(arg_name, arg, 0) self.arg_pass_in_msg.append(self.invalid_arg_msg[arg_name][self.invalid_arg[arg_name].index(arg)]) # Determine the expected result exp_result = self.result_det(self.arg_pass_in_msg) # Use zip(dict.keys(), dict.values()) # can convert dict into a list of tuples self.http.set_pass_in_with_file(zip(self.arg_pass_in.keys(), self.arg_pass_in.values())) # Need to upload a file, set flag to 1 # to change the type of HTTP request self.http.request(1) self.total_case = self.total_case + 1 # Print status print 'Processing Case ID {0}.\n{1}% to finish Campaign Create API.'.format('CC'+str(self.total_case), \ self.total_case*100/TOTAL_CASE) # check the response self.err_response_check(exp_result) ######################################################################## ######################################################################## # Part III: Invalid case with two invalid arguments # Here I reduce the number of test cases by only picking one combination # of valid case for arg_name1 in self.para_name_list: index1 = self.para_name_list.index(arg_name1) for arg_name2 in self.para_name_list[index1+1:]: # add those two arguments into arg_pass_in dict for arg1 in self.invalid_arg[arg_name1]: self.form_one_valid_arg() self.update_arg_pass_in(arg_name1, arg1, 0) self.arg_pass_in_msg.append(self.invalid_arg_msg[arg_name1][self.invalid_arg[arg_name1].index(arg1)]) for arg2 in self.invalid_arg[arg_name2]: self.update_arg_pass_in(arg_name2, arg2, 0) self.arg_pass_in_msg.append(self.invalid_arg_msg[arg_name2][self.invalid_arg[arg_name2].index(arg2)]) # Determine the expected result exp_result = self.result_det(self.arg_pass_in_msg) # Use zip(dict.keys(), dict.values()) # can convert dict into a list of tuples self.http.set_pass_in_with_file(zip(self.arg_pass_in.keys(), self.arg_pass_in.values())) # Need to upload a file, set flag to 1 # to change the type of HTTP request self.http.request(1) self.total_case = self.total_case + 1 # Print status print 'Processing Case ID {0}.\n{1}% to finish Campaign Create API.'.format('CC'+str(self.total_case), \ self.total_case*100/TOTAL_CASE) # check the response self.err_response_check(exp_result) # update arg_pass_in and arg_pass_in_msg self.update_arg_pass_in(arg_name2, arg2, 1) self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1)
def blackbox_test(self): # Should refresh the server campaign with URN gconst.CAMP_URN HTTP.delete_camp(self.host, self.TOKEN, gconst.CAMP_URN) HTTP.create_camp(self.host, self.TOKEN, gconst.CLS_URN_LIST) # Combination of three kinds of test cases defined in README # Special cases for 'Wrong argument name' and 'Missing Argument' # Part I: Valid Case for a in self.valid_arg['auth_token']: self.arg_pass_in = {} self.arg_pass_in_msg = [] self.arg_pass_in['auth_token'] = a self.arg_pass_in_msg.append(self.valid_arg_msg['auth_token'][0]) for clt in self.valid_arg['client']: self.arg_pass_in['client'] = clt self.arg_pass_in_msg.append(self.valid_arg_msg['client'][self.valid_arg['client'].index(clt)]) for camp in self.valid_arg['campaign_urn_list']: self.update_arg_pass_in('campaign_urn_list', camp, 0) self.arg_pass_in_msg.append(self.valid_arg_msg['campaign_urn_list'][self.valid_arg['campaign_urn_list'].index(camp)]) for cls in self.valid_arg['class_urn_list']: self.update_arg_pass_in('class_urn_list', cls, 0) self.arg_pass_in_msg.append(self.valid_arg_msg['class_urn_list'][self.valid_arg['class_urn_list'].index(cls)]) # Determine the expected result exp_result = self.result_det(self.arg_pass_in_msg) # HTTP request part # Increment the total and invalid cases at the same time self.http.set_pass_in(self.arg_pass_in) self.http.request(0) self.total_case = self.total_case + 1 # Print status print 'Processing Case ID {0}.\n{1}% to finish User Read API.'.format('UR'+str(self.total_case), self.total_case*100/TOTAL_CASE) # Check the response if exp_result == 'v': if (self.http.http_code != 200) or (self.http.cont_dict['result'] != 'success'): HTTP.write_err_report(self.err_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ '{"result": "success", "data":...}') # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('UR'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) else: print >> sys.stderr, 'Error: Invalid valid test case' sys.exit(1) # update arg_pass_in and arg_pass_in_msg self.update_arg_pass_in('class_urn_list', cls, 1) self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg self.update_arg_pass_in('campaign_urn_list', camp, 1) self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg del self.arg_pass_in['client'] self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg del self.arg_pass_in['auth_token'] self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) ######################################################################## ######################################################################## # Part II: Invalid case with one invalid argument for para in self.para_name_list: index = self.para_name_list.index(para) # each turn pick one as invalid argument self.para_name_list.remove(para) arg1 = para # invalid arg arg2 = self.para_name_list[0] # valid arg arg3 = self.para_name_list[1] # valid arg arg4 = self.para_name_list[2] # valid arg # Add arg 1 for a1 in self.invalid_arg[arg1]: self.arg_pass_in = {} self.arg_pass_in_msg = [] self.update_arg_pass_in(arg1, a1, 0) self.arg_pass_in_msg.append(self.invalid_arg_msg[arg1][self.invalid_arg[arg1].index(a1)]) # Add arg 2 for a2 in self.valid_arg[arg2]: self.update_arg_pass_in(arg2, a2, 0) self.arg_pass_in_msg.append(self.valid_arg_msg[arg2][self.valid_arg[arg2].index(a2)]) # Add arg 3 for a3 in self.valid_arg[arg3]: self.update_arg_pass_in(arg3, a3, 0) self.arg_pass_in_msg.append(self.valid_arg_msg[arg3][self.valid_arg[arg3].index(a3)]) # Add arg 4 for a4 in self.valid_arg[arg4]: self.update_arg_pass_in(arg4, a4, 0) self.arg_pass_in_msg.append(self.valid_arg_msg[arg4][self.valid_arg[arg4].index(a4)]) # Result determine exp_result = self.result_det(self.arg_pass_in_msg) # HTTP request # Increment the total and invalid cases at the same time self.http.set_pass_in(self.arg_pass_in) self.http.request(0) self.total_case = self.total_case + 1 print 'Processing Case ID {0}.\n{1}% to finish User Read API.'.format('UR'+str(self.total_case), self.total_case*100/TOTAL_CASE) # result check if exp_result == gconst.AUTH_FAIL: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.AUTH_FAIL): HTTP.write_err_report(self.err_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.AUTH_FAIL+': '+gconst.ERROR[gconst.AUTH_FAIL]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('UR'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.CLT_TOO_LONG: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.CLT_TOO_LONG): HTTP.write_err_report(self.err_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.CLT_TOO_LONG+': '+gconst.ERROR[gconst.CLT_TOO_LONG]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('UR'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.NO_PERM_IN_CAMP: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.NO_PERM_IN_CAMP): HTTP.write_err_report(self.err_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.NO_PERM_IN_CAMP+': '+gconst.ERROR[gconst.NO_PERM_IN_CAMP]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('UR'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.INVALID_CAMP_URN: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_CAMP_URN): HTTP.write_err_report(self.err_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.INVALID_CAMP_URN+': '+gconst.ERROR[gconst.INVALID_CAMP_URN]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('UR'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.INVALID_CLS_URN: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_CLS_URN): HTTP.write_err_report(self.err_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.INVALID_CLS_URN+': '+gconst.ERROR[gconst.INVALID_CLS_URN]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('UR'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.NO_PERM_IN_CLS: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.NO_PERM_IN_CLS): HTTP.write_err_report(self.err_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.NO_PERM_IN_CLS+': '+gconst.ERROR[gconst.NO_PERM_IN_CLS]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('UR'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) else: print >> sys.stderr, 'Error: Unexpected single argument invalid test case' sys.exit(1) # update arg_pass_in and arg_pass_in_msg self.update_arg_pass_in(arg4, a4, 1) self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg self.update_arg_pass_in(arg3, a3, 1) self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg self.update_arg_pass_in(arg2, a2, 1) self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg self.update_arg_pass_in(arg1, a1, 1) self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # restore the para_name_list self.para_name_list.insert(index, para) ######################################################################## ######################################################################## # Part III: Invalid case with two invalid arguments # Get first invalid arg for arg1 in self.para_name_list: index1 = self.para_name_list.index(arg1) # each turn pick one as invalid argument self.para_name_list.remove(arg1) # Get second invalid arg for arg2 in self.para_name_list[index1:]: # reduce half of the redundency index2 = self.para_name_list.index(arg2) self.para_name_list.remove(arg2) # Get other two arg arg3 = self.para_name_list[0] arg4 = self.para_name_list[1] # Add arg 1 for a1 in self.invalid_arg[arg1]: self.arg_pass_in = {} self.arg_pass_in_msg = [] self.update_arg_pass_in(arg1, a1, 0) self.arg_pass_in_msg.append(self.invalid_arg_msg[arg1][self.invalid_arg[arg1].index(a1)]) # Add arg 2 for a2 in self.invalid_arg[arg2]: self.update_arg_pass_in(arg2, a2, 0) self.arg_pass_in_msg.append(self.invalid_arg_msg[arg2][self.invalid_arg[arg2].index(a2)]) # Add arg 3 for a3 in self.valid_arg[arg3]: self.update_arg_pass_in(arg3, a3, 0) self.arg_pass_in_msg.append(self.valid_arg_msg[arg3][self.valid_arg[arg3].index(a3)]) # Add arg 4 for a4 in self.valid_arg[arg4]: self.update_arg_pass_in(arg4, a4, 0) self.arg_pass_in_msg.append(self.valid_arg_msg[arg4][self.valid_arg[arg4].index(a4)]) # Result determine exp_result = self.result_det(self.arg_pass_in_msg) # HTTP request # Increment the total and invalid cases at the same time self.http.set_pass_in(self.arg_pass_in) self.http.request(0) self.total_case = self.total_case + 1 print 'Processing Case ID {0}.\n{1}% to finish User Read API.'.format('UR'+str(self.total_case), \ self.total_case*100/TOTAL_CASE) # Result Check if exp_result == gconst.AUTH_FAIL: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.AUTH_FAIL): HTTP.write_err_report(self.err_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.AUTH_FAIL+': '+gconst.ERROR[gconst.AUTH_FAIL]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('UR'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.NO_PERM_IN_CAMP: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.NO_PERM_IN_CAMP): HTTP.write_err_report(self.err_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.NO_PERM_IN_CAMP+': '+gconst.ERROR[gconst.NO_PERM_IN_CAMP]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('UR'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.INVALID_CAMP_URN: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_CAMP_URN): HTTP.write_err_report(self.err_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.INVALID_CAMP_URN+': '+gconst.ERROR[gconst.INVALID_CAMP_URN]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('UR'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.INVALID_CLS_URN: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.INVALID_CLS_URN): HTTP.write_err_report(self.err_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.INVALID_CLS_URN+': '+gconst.ERROR[gconst.INVALID_CLS_URN]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('UR'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) elif exp_result == gconst.NO_PERM_IN_CLS: if (self.http.http_code != 200) or \ (self.http.cont_dict['result'] != 'failure') or \ (self.http.cont_dict['errors'][0]['code'] != gconst.NO_PERM_IN_CLS): HTTP.write_err_report(self.err_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents,\ gconst.NO_PERM_IN_CLS+': '+gconst.ERROR[gconst.NO_PERM_IN_CLS]) # increment the invalid case id list and unexpected case counter self.invalid_case_id_list.append('UR'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'UR'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) else: print >> sys.stderr, 'Error: Unexpected single argument invalid test case' sys.exit(1) # update arg_pass_in and arg_pass_in_msg self.update_arg_pass_in(arg4, a4, 1) self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg self.update_arg_pass_in(arg3, a3, 1) self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg self.update_arg_pass_in(arg2, a2, 1) self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # update arg_pass_in and arg_pass_in_msg self.update_arg_pass_in(arg1, a1, 1) self.arg_pass_in_msg.pop(len(self.arg_pass_in_msg)-1) # restore the para_name_list self.para_name_list.insert(index2, arg2) # restore the para_name_list self.para_name_list.insert(index1, arg1)