def blackbox_test(self): # Should create a new campaign first HTTP.create_camp(self.host, self.TOKEN, gconst.CLS_URN) # Combination of three kinds of test cases defined in README # 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"]: self.arg_pass_in["campaign_urn"] = camp self.arg_pass_in_msg.append( self.valid_arg_msg["campaign_urn"][self.valid_arg["campaign_urn"].index(camp)] ) for run in self.valid_arg["running_state"]: self.update_arg_pass_in("running_state", run, 0) 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.update_arg_pass_in("privacy_state", pri, 0) 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.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)] ) for xml in self.valid_arg["xml"]: self.update_arg_pass_in("xml", xml, 0) 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)] ) for add in self.valid_arg["user_role_list_add"]: self.update_arg_pass_in("user_role_list_add", add, 0) self.arg_pass_in_msg.append( self.valid_arg_msg["user_role_list_add"][ self.valid_arg["user_role_list_add"].index(add) ] ) for remove in self.valid_arg["user_role_list_remove"]: self.update_arg_pass_in("user_role_list_remove", remove, 0) self.arg_pass_in_msg.append( self.valid_arg_msg["user_role_list_remove"][ self.valid_arg["user_role_list_remove"].index(remove) ] ) # 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 Update API.".format( "CD" + 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, "CD" + 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("CD" + str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report( self.succ_report, "CD" + 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("user_role_list_remove", remove, 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("user_role_list_add", add, 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("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 self.update_arg_pass_in("xml", xml, 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("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("privacy_state", pri, 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("running_state", run, 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["campaign_urn"] 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 Update API.".format( "CD" + 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 Update API.".format( "CD" + 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 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,\ 'CD'+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('CD'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 # Unexpected 'success' delete campaign, need to create a new campaign if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'): result = HTTP.create_camp(self.host, self.TOKEN, gconst.CLS_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot create a new campaign' sys.exit(1) else: HTTP.write_succ_report(self.succ_report,\ 'CD'+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,\ 'CD'+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('CD'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 # Unexpected 'success' delete campaign, need to create a new campaign if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'): result = HTTP.create_camp(self.host, self.TOKEN, gconst.CLS_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot create a new campaign' sys.exit(1) else: HTTP.write_succ_report(self.succ_report,\ 'CD'+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,\ 'CD'+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('CD'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 # Unexpected 'success' delete campaign, need to create a new campaign if (self.http.http_code == 200) and (self.http.cont_dict['result'] == 'success'): result = HTTP.create_camp(self.host, self.TOKEN, gconst.CLS_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot create a new campaign' sys.exit(1) else: HTTP.write_succ_report(self.succ_report,\ 'CD'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) else: print >> sys.stderr, 'Error: Unexpected invalid test case' sys.exit(1)
def blackbox_test(self): # Should create a new campaign first HTTP.create_camp(self.host, self.TOKEN, gconst.CLS_URN) # Combination of three kinds of test cases defined in README # 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']: self.arg_pass_in['campaign_urn'] = camp self.arg_pass_in_msg.append(self.valid_arg_msg['campaign_urn'][self.valid_arg['campaign_urn'].index(camp)]) # 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 Campaign Delete API.'.format('CD'+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,\ 'CD'+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('CD'+str(self.total_case)) self.unexpect_case = self.unexpect_case + 1 else: HTTP.write_succ_report(self.succ_report,\ 'CD'+str(self.total_case),\ self.arg_pass_in,\ self.http.contents) # need to create the campaign with expected deleting result = HTTP.create_camp(self.host, self.TOKEN, gconst.CLS_URN) if result != 'success': print >> sys.stderr, 'Error: Cannot create a new 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 del self.arg_pass_in['campaign_urn'] 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) arg = [] # each turn pick one as invalid argument self.para_name_list.remove(para) # store the only one invalid argument arg.append(para) # store all other valid arguments for x in range(1,3): arg.append(self.para_name_list[x-1]) # Add first argument for a0 in self.invalid_arg[arg[0]]: self.arg_pass_in = {} self.arg_pass_in_msg = [] self.update_arg_pass_in(arg[0], a0, 0) self.arg_pass_in_msg.append(self.invalid_arg_msg[arg[0]][self.invalid_arg[arg[0]].index(a0)]) # Add second arguemnt for a1 in self.valid_arg[arg[1]]: self.update_arg_pass_in(arg[1], a1, 0) self.arg_pass_in_msg.append(self.valid_arg_msg[arg[1]][self.valid_arg[arg[1]].index(a1)]) # Add third arguemnt for a2 in self.valid_arg[arg[2]]: self.update_arg_pass_in(arg[2], a2, 0) self.arg_pass_in_msg.append(self.valid_arg_msg[arg[2]][self.valid_arg[arg[2]].index(a2)]) # 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 Campaign Delete API.'.format('CD'+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[2], 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(arg[1], a1, 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(arg[0], a0, 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 argument for para1 in self.para_name_list: index1 = self.para_name_list.index(para1) arg = [] arg.append(para1) # each turn remove one invalid parameter from the para_name_list self.para_name_list.remove(para1) # Get second invalid argument for para2 in self.para_name_list[index1:]: index2 = self.para_name_list.index(para2) arg = [para1] arg.append(para2) # each turn remove one invalid parameter from the para_name_list self.para_name_list.remove(para2) # Store all other valid argument arg.append(self.para_name_list[0]) # Add first argument for a0 in self.invalid_arg[arg[0]]: self.arg_pass_in = {} self.arg_pass_in_msg = [] self.update_arg_pass_in(arg[0], a0, 0) self.arg_pass_in_msg.append(self.invalid_arg_msg[arg[0]][self.invalid_arg[arg[0]].index(a0)]) # Add second arguemnt for a1 in self.invalid_arg[arg[1]]: self.update_arg_pass_in(arg[1], a1, 0) self.arg_pass_in_msg.append(self.invalid_arg_msg[arg[1]][self.invalid_arg[arg[1]].index(a1)]) # Add third arguemnt for a2 in self.valid_arg[arg[2]]: self.update_arg_pass_in(arg[2], a2, 0) self.arg_pass_in_msg.append(self.valid_arg_msg[arg[2]][self.valid_arg[arg[2]].index(a2)]) # 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 Campaign Delete API.'.format('CD'+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[2], 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(arg[1], a1, 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(arg[0], a0, 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, para2) # restore the para_name_list self.para_name_list.insert(index1, para1)
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)