예제 #1
0
    def get_college_detail(self,
                           url,
                           list_items,
                           detail_info={},
                           mod='college_detail'):
        send_url = self.request.get_url(url, mod)

        try:
            res = Request().set_request(send_url)
            res.encoding = 'gbk'
            soup = BeautifulSoup(res.text, "html.parser")

            dom = soup.find('div', {'class': 'scores_List'})
            dl = dom.find_all('dl')

            for dl_item in dl:
                dt = dl_item.find('dt')
                college_name = dt.get_text().strip()

                if college_name in list_items:
                    continue

                img = dt.find('img').get('src')
                img_url = Utils().savePic(img,
                                          path_in='logo/' + college_name + '-')

                list_items[college_name] = {'logo': img_url}

            print 'ok: ', send_url, len(dl)
        except IOError:
            print 'failed: ', send_url
        finally:
            print json.dumps(list_items, encoding='UTF-8', ensure_ascii=False)
            time.sleep(5)
            return list_items, detail_info
    def test_register(self,case):
        # 使用正则,首先从数据库查找到最大手机号加1,通过正则替换excel中的参数---还需再改!!!
        # if case.case_id == 1:
        #     # 从数据库找到最大手机号+1
        #     max_phone_old = mysql.fetch_one(sql)['mobilephone']
        #     max_phone = int(max_phone_old) + 1
        #     print("最大手机号是:",max_phone)
        #     # 新的手机号替换excel中的手机号
        #     phone = re.findall(pattern='\d{11}', string=case.data)[0]    # 先从excel中取出手机号
        #     case.data = case.data.replace(phone,str(max_phone))  # replace替换

        # 也可以不用正则,取出case.data字典里的手机号,直接赋值替换
        data = json.loads(case.data)  # 从excel中取到的data是一个字符串,loads() 把字符串序列化为字典
        if data['mobilephone'] == '${register}':     # 判断是否需要进行参数化
            max_phone_new = int(max_phone_old) + 1   # 取到数据库里面最大的手机号码,进行加1
            data['mobilephone'] = max_phone_new     # 赋值替换excel中的手机号

        resp = Request(method=case.method, url=case.url, data=data)  # request请求时,data一定要是字典类型
        print("status_code:", resp.get_status_code())  # 打印响应码
        resp_dict = resp.get_json()  # 获取请求响应,字典
        self.assertEqual(case.expected, resp.get_text())

        # 数据库校验
        if resp_dict['code'] == 10001:  # 注册成功的数据校验,判断数据库member表有这条数据
            sql = 'select * from future.member where mobilephone = "{0}"'.format(max_phone_new)
            member = self.mysql.fetch_one(sql)   # member是字典类型
            expected = max_phone_new
            if member is not None:  # 正常注册成功,不应该返回None
                self.assertEqual(expected, member['mobilephone'])
            else:         # 返回None,代表注册成功之后但是数据库里面没有插入数据
                print("注册失败,数据库没有插入数据")
예제 #3
0
 def __init__(self):
     self.dt = Data()
     readIni = ReadIni()
     self.base_url = readIni.get_value('base_url', 'api')
     self.schoolweb_url = readIni.get_value('schoolweb_url', 'api')
     self.req = Request()
     self.row_total = self.dt.row_total()
예제 #4
0
    def test_recharge(self, case):
        # 参数化处理
        data = DoRegex.replace(case.data)
        # 将字符串序列化成字典
        data = json.loads(data)
        if hasattr(Context, 'cookies'):  # 判断是否有cookies
            cookies = getattr(Context, 'cookies')  # 获取放到上下文里面的cookies
        else:
            cookies = None
        resp = Request(method=case.method, url=case.url, data=data, cookies=cookies)  # 通过封装的Request类来完成接口的调用
        # 判断有没有cookie
        if resp.get_cookies():  # 判断返回里面是否有cookies
            setattr(Context, 'cookies', resp.get_cookies())  # 放入到上下文中
        resp_dict = resp.get_json()  # 获取请求响应,字典
        self.assertEqual(case.expected, int(resp_dict['code']))  # 判断响应返回的code 是否与期望结果一致

        actual = self.mysql.fetch_one(self.sql)['LeaveAmount']  # 再次获取账户余额
        print("测试{0}后的金额".format(case.title), actual)
        # 充值成功,判断余额增加
        if resp_dict['code'] == '10001' and resp_dict['msg'] == "充值成功":
            amount = float(data['amount'])  # 充值金额
            print('充值金额', amount)
            expect = float(self.before_amount) + amount  # 充值成功,期望的账户余额= 原来余额 + 充值金额
            self.assertEqual(expect, actual)  # 判断期望结果与实际结果是否一致
        elif resp_dict['code'] != '10001':
            expect = self.before_amount  # 充值失败,期望结果:余额未增加
            self.assertEqual(expect, actual)  # 判断期望结果与实际结果是否一致
예제 #5
0
    def __init__(self):
        self.is_to_excel = cfg.IS_TO_EXCEL
        self.is_email = cfg.IS_EMAIL

        self.request = Request()
        self.html = HtmlController()
        self.excel = ExcelController()
예제 #6
0
 def test_login(self, case):
     data = json.loads(case.data)
     resp = Request(method=case.method, url=case.url,
                    data=data)  # 通过封装的Request类来完成接口的调用
     print('test data:', data)
     print('status_code:', resp.get_status_code())  # 打印响应码
     resp_dict = resp.get_json()  # 获取请求响应,字典
     self.assertEqual(case.expected, resp.get_json_code())
예제 #7
0
 def test_login(self, case):  # 必须传输一条case
     data = json.loads(case.data)
     res = Request(method=case.method, url=case.url, data=data)
     print(res.get_json())
     try:
         self.assertEqual(eval(case.expected), res.get_json())
     except AssertionError as e:
         print("{} not found".format(e))
         raise e
예제 #8
0
 def test_recharge(self, case):  # 必须传输一条case
     my_logger = MyLog()
     data = DoRegex.replace(case.data)  # 首先从excel中取出来,然后做正则
     data = json.loads(data)  # 然后在loads
     if hasattr(Context, 'cookies'):  # 第一次登陆没有cookies,所以要判断
         # 参数化处理
         cookies = getattr(Context, 'cookies')
     else:
         cookies = None
     res = Request(method=case.method,
                   url=case.url,
                   data=data,
                   cookies=cookies)
     # 判断有没有cookies
     if res.get_cookies():
         setattr(Context, 'cookies', res.get_cookies())
     my_logger.debug(res.get_json())
     try:
         self.assertEqual(str(case.expected), res.get_json()['code'])
     except AssertionError as e:
         my_logger.error("{} not found".format(e))
         raise e
     if res.get_json()['msg'] == '充值成功':
         try:
             self.assertEqual(str(self.leaveamount + 10),
                              res.get_json()['data']['leaveamount'])
         except AssertionError as a:
             my_logger.error("余额不正确,报错{}".format(a))
예제 #9
0
    def test_case(self, **args):
        # module,case_name,case_num,case_imp,request_type,request_url,request_param,case_except,case_author
        self.model_name = args.get('Model')
        self.case_name = args.get('Case')

        self._testMethodDoc = self.model_name + '_' + self.case_name  # 单个文件运行时请注释此行

        self.url = args.get('Url')
        self.login_state = args.get('Login_State')
        self.method = args.get('Method')
        self.data = args.get('Data')
        self.status_code = args.get('Status_Code')
        self.expect_type = args.get('Expect_Type')
        self.expect = args.get('Expect')

        test = assertion.Assertions()
        request = Request()

        if self.method == 'post':
            my_log.info("开始执行post请求!模块名称为: %s ,用例名称为 %s" %
                        (self.model_name, self.case_name))
            r = request.post_request(url=self.url,
                                     data=self.data,
                                     login_state=self.login_state)
            assert test.assert_code(r['code'], self.status_code)
            if self.expect_type == 'body':
                assert test.assert_in_text(r['body'], self.expect)
            elif self.expect_type == 'text':
                assert self.expect in r['text']
            elif self.expect_type == 'time_consuming':
                assert test.assert_in_text(r['time_consuming'], self.expect)
            elif self.expect_type == 'time_total':
                assert test.assert_in_text(r['time_total'], self.expect)
            else:
                my_log.error('excel文件中设置的预期类型不符合格式!')
        elif self.method == 'get':
            my_log.info("开始执行get请求!模块名称为: %s ,用例名称为 %s" %
                        (self.model_name, self.case_name))
            r = request.get_request(url=self.url,
                                    data=self.data,
                                    login_state=self.login_state)
            assert test.assert_code(r['code'], self.status_code)
            if self.expect_type == 'body':
                assert test.assert_in_text(r['body'], self.expect)
            elif self.expect_type == 'text':
                assert self.expect in r['text']
            elif self.expect_type == 'time_consuming':
                assert test.assert_time(r['time_consuming'], self.expect)
            elif self.expect_type == 'time_total':
                assert test.assert_time(r['time_total'], self.expect)
            else:
                my_log.error('excel文件中设置的预期类型不符合格式!')
        else:
            my_log.error("暂不支持此种请求方式!")
예제 #10
0
    def __init__(self):

        #打开用例获取login_sheet 中的第一行用例
        self.login_case = Read_Excel('../data/smile_tasks.xlsx', 'login')
        self.login_case.open_excel()
        self.table = self.login_case.get_sheet_table()
        self.ncols = self.login_case.get_ncols(self.table)
        self.login_case_data = self.login_case.get_test_case(
            self.table, self.ncols)
        #定义一个request
        self.request = Request()
        #定义log
        self.log = Log()
예제 #11
0
 def test_login(self, case):
     data = json.loads(case.data)
     logger1.my_logger.info('测试用例名称:{0}'.format(case.title))
     logger1.my_logger.info('测试用例数据:{0}'.format(case.data))
     resp = Request(method=case.method, url=case.url,
                    data=data)  # 通过封装的Request类来完成接口的调用
     logger1.my_logger.debug('status_code:{0}'.format(
         resp.get_status_code()))  # 打印响应码
     resp_dict = resp.get_json()  # 获取请求响应,字典
     try:
         self.assertEqual(case.expected, resp.get_text())
     except AssertionError as e:
         logger1.my_logger.error('测试失败')
예제 #12
0
 def test_list(self, case):
     my_logger = MyLog()
     if case.data != None:
         data = DoRegex.replace(case.data)  # 正则调用,替换正则表达式的数据
         data = json.loads(data)
         if hasattr(Context, 'cookies'):
             cookies = getattr(Context, 'cookies')
         else:
             cookies = None
         res = Request(method=case.method, url=case.url, data=data, cookies=cookies)
         print(res.get_json())
         if res.get_cookies():
             setattr(Context, 'cookies', res.get_cookies())
예제 #13
0
    def test_add(self, case):
        data = DoRegex.replace(case.data)
        data = json.loads(data)
        if hasattr(Context, 'cookies'):
            cookies = Context.cookies
        else:
            cookies = None
        #请求成功后,返回response
        resp = Request(method=case.method,
                       url=case.url,
                       data=data,
                       cookies=cookies)
        if resp.get_cookies():  # 将cookies动态写入上下文管理器中
            setattr(Context, 'cookies', resp.get_cookies())
        print("用例名称:", case.title)
        resp_dict = resp.get_json()
        print(resp.get_text())
        self.assertEqual(str(case.expected),
                         resp_dict['code'])  # check the response code firstly

        # Check that the login case is successful
        if case.title == '管理员正常登录':
            try:
                self.assertEqual(str(case.expected), resp_dict['code'])
                TestResult = 'PASS'
                do_excel.write_result_by_case_id('add', case.case_id,
                                                 resp.get_text(), TestResult)
            except AssertionError as e:
                TestResult = 'Fail'
                do_excel.write_result_by_case_id('add', case.case_id,
                                                 resp.get_text(), TestResult)
                raise e
예제 #14
0
class Common():
    def __init__(self):

        #打开用例获取login_sheet 中的第一行用例
        self.login_case = Read_Excel('../data/smile_tasks.xlsx', 'login')
        self.login_case.open_excel()
        self.table = self.login_case.get_sheet_table()
        self.ncols = self.login_case.get_ncols(self.table)
        self.login_case_data = self.login_case.get_test_case(
            self.table, self.ncols)
        #定义一个request
        self.request = Request()
        #定义log
        self.log = Log()

    def login(self):

        #request所需要的参数
        method = self.login_case_data['method']
        url = self.login_case_data['url']
        username = self.login_case_data['username']
        password = self.login_case_data['password']
        param = {'username': username, 'password': password}

        #发送请求
        try:
            r = self.request.request(method, url, param)
            r_json = r.json()
            token = r_json['token']
        except:
            self.log.error('get token failed')

        return token
예제 #15
0
class Set_pattern(unittest.TestCase):
    def setUp(self):

        self.request = Request()
        self.token = get_antelope_token()

    def test_set_pattern(self):

        global test_data
        test_data = test_data[0]
        #print(test_data)

        #请求参数
        para = test_data['para']
        #print(para)

        #请求头
        header = {
            'Content-Type': 'application/x-www-form-urlencoded',
            'token': self.token
        }
        print(header)

        #请求头
        r = self.request.request(test_data['method'], test_data['url'], para,
                                 header)
        actual_result = r.json()

        #断言
        self.assertEqual(actual_result['code'], test_data['code'])

    def tearDown(self):
        pass
class LoginTest(unittest.TestCase):
    do_excel = DoExcel(constants.case_file)  # 读取cases.xlsx
    cases = do_excel.get_cases('login')  # 指定读取login测试数据
    request = Request()  # 实例化对象

    def setUp(self):
        pass

    def tearDown(self):
        pass

    @data(*cases)
    def test_login(self, case):
        logger.info("开始执行第{0}用例".format(case.id))
        # 使用封装好的request 来完成请求
        resp = self.request.request(case.method, case.url, case.data)

        try:
            # 将返回结果和期望结果进行匹配
            self.assertEqual(case.expected, resp.text, 'login error')
            # 一致就写入Excel的结果为Pass
            self.do_excel.write_result('login', case.id + 1, resp.text, 'Pass')
            logger.info("第{0}用例执行结果:PASS".format(case.id))
        except AssertionError as e:
            # 不一致就写入Excel的结果为Fail,并抛出异常
            self.do_excel.write_result('login', case.id + 1, resp.text, 'Fail')
            logger.error("第{0}用例执行结果:FAIL".format(case.id))
            raise e
예제 #17
0
 def test_register(self, case):  # 必须传输一条case
     data = json.loads(case.data)
     if data['mobilephone'] == '${register}':
         data['mobilephone'] = str(int(self.max_phone) + 1)
         print(data)
     res = Request(method=case.method, url=case.url, data=data)
     print(res.get_json())
     self.assertEqual(str(case.expected), res.get_json()['code'])
     # 数据库数据校验
     sql = "select l.MobilePhone from future.member l where l.MobilePhone ={}".format(
         int(self.max_phone) + 1)
     # print(sql)
     expected = int(self.max_phone) + 1
     member = self.mysql.fetch_one(sql)
     if member is not None:
         self.assertEqual(expected, member['MobilePhone'])
    def schedule_and_build_instances(self, context, build_requests,
                                     request_specs, image, admin_password,
                                     injected_files, requested_networks,
                                     block_device_mapping):
        index = 0

        for build_request in build_requests:
            request_spec = request_specs[index]

            index += 1

            data = {
                'build_requests': [build_request],
                'request_specs': [request_spec],
                'image': image,
                'admin_password': admin_password,
                'injected_files': injected_files,
                'requested_networks': requested_networks,
                'block_device_mapping': block_device_mapping
            }

            req = {
                "context": context,
                "data": data,
                "action": "schedule_and_build_instances"
            }

            request = Request.fromDict(req)

            self.nova_manager.notify(event_type="SERVER_CREATE",
                                     request=request)
예제 #19
0
class RechargeTest(unittest.TestCase):
    cases = doexcel.DoExcel(contants.case_file,
                            "recharge").get_data("recharge")
    request = Request()

    def setUp(self):
        pass

    def tearDown(self):
        pass

    @data(*cases)
    def test_login(self, case):
        print("开始执行第{}个测试用例:".format(case.case_id))
        resp = self.request.request(method=case.method,
                                    url=case.url,
                                    data=case.data)
        doexcels = doexcel.DoExcel(contants.case_file, "recharge")
        try:
            self.assertEqual(case.expected, resp.text)
            doexcels.write_back(row=case.case_id + 2,
                                col=8,
                                value="PASS",
                                sheet_name="recharge")
        except AssertionError as e:
            doexcels.write_back(row=case.case_id + 2,
                                col=8,
                                value="FAIlED",
                                sheet_name="recharge")
            raise e
        doexcels.write_back(case.case_id + 2,
                            7,
                            resp.text,
                            sheet_name="recharge")
        print(resp.text)
예제 #20
0
class InvestTest(unittest.TestCase):
    cases = doexcel.DoExcel(contants.case_file, "invest").get_data("invest")
    request = Request()
    @classmethod
    def setUpClass(cls):
        cls.mysql = MysqlUtil()
    @classmethod
    def tearDownClass(cls):
        cls.mysql.close()

    @data(*cases)
    def test_invest(self,case):
        readconfig = ReadConfig()
        pre_url = readconfig.get("api","pre_url")
        print("开始执行第{}个测试用例:".format(case.case_id))
        case.data = replace(case.data)
        resp = self.request.request(method=case.method,url = pre_url+case.url,data=case.data)
        doexcels = doexcel.DoExcel(contants.case_file, "invest")
        try:
            self.assertEqual(case.expected,resp.text)
            doexcels.write_back(row=case.case_id + 2, col=8, value="PASS", sheet_name="invest")
            #加一层判断,判断加标是否成功,如果成功,就把标的的ID查出来反射给类的属性,以便下一条用例取
            if resp.json()["msg"] == "加标成功":
                load_member_id = getattr(Context,"loan_member_id")
                mysql = MysqlUtil()
                sql = "select Id from future.loan where MemberID={} order by CreateTime desc limit 1".format(load_member_id)
                loan_id = mysql.fetchone(sql)[0]
                setattr(Context,"loan_id",str(loan_id))
        except AssertionError as  e:
            doexcels.write_back(row=case.case_id + 2, col=8, value="FAIlED", sheet_name="invest")
        doexcels.write_back(case.case_id + 2,7,resp.text,sheet_name="invest")
        print(resp.text)
예제 #21
0
class LoginTest(unittest.TestCase):
    # 可类里,也可模块外
    do_excel = DoExcel(contants.case_file)  # 传入cases.xlsx
    cases = do_excel.read('login')
    request = Request()  # 实例化一个对象
    # 可类里,也可模块外

    def setUp(self):
        pass

    @data(*cases)  # 此处传入数据,so读数据就要从test_login()方法移到方法外面,for case in cases:也需删掉
    def test_login(self, case):  # 加case接收解包数据
        print("开始执行第{0}行用例".format(case.case_id))
        # 使用分装好的request来完成请求
        resp = self.request.request(case.method, case.url, case.data)  # 实例对象已移到外面,这里要加self.
        # 将返回结果与期望结果对比
        # 当用unittest时,比对用断言,不用if恒等==手动了
        try:
            self.assertEqual(case.expected, resp.text, 'login error')
            # 一致就写入Excel的结果PASS
            self.do_excel.write_back(case.case_id+1, resp.text, 'PASS')  # 实例对象已放外面,类变量加self.
            print("第{0}行用例执行结果:PASS".format(case.case_id))
        except AssertionError as e:
            self.do_excel.write_back(case.case_id, resp.text, 'FAIL')  # 实例对象已放外面,类变量加self.调用
            print("第{0}行用例执行结果:FAIL".format(case.case_id))
            raise e

    def tearDown(self):
        pass
예제 #22
0
class LoginTest(unittest.TestCase):
    cases = doexcel.DoExcel(contants.case_file, "login").get_data("login")
    request = Request()

    def setUp(self):
        pass

    def tearDown(self):
        pass

    @data(*cases)
    def test_login(self, case):
        logg.info("开始执行第{}个测试用例:".format(case.case_id))
        resp = self.request.request(method=case.method,
                                    url=case.url,
                                    data=case.data)
        doexcels = doexcel.DoExcel(contants.case_file, "login")
        try:
            self.assertEqual(case.expected, resp.text)
            doexcels.write_back(row=case.case_id + 1,
                                col=8,
                                value="PASS",
                                sheet_name="login")
        except AssertionError as e:
            doexcels.write_back(row=case.case_id + 1,
                                col=8,
                                value="FAIlED",
                                sheet_name="login")
            logg.error("第{}个用例执行结果:failed".format(case.case_id))
        doexcels.write_back(case.case_id + 1, 7, resp.text, sheet_name="login")
        logg.info(resp.text)
예제 #23
0
class LoginTest(unittest.TestCase):
    do_excel = DoExcel(contants.case_file)  # 传入test.xlsx
    cases = do_excel.get_data('login')  #定位表单
    request = Request()  #实例化request

    def setUp(self):
        pass

    @data(*cases)
    def test_login(self, item):  #用一个变量来解释data传递的数据

        # 使用封装好的request 来完成请求
        logger.info("开始执行第{}用例".format(item.id))
        resp = self.request.request(item.method, item.url, item.data)
        # 将返回结果和期望结果进行匹配
        try:
            self.assertEqual(item.expected, resp.text, "login error")
            self.do_excel.write_result('login', item.id + 1, resp.text, 'PASS')
            logger.info("第{}用例执行结果:PASS".format(item.id))
        except AssertionError as e:
            self.do_excel.write_result('login', item.id + 1, resp.text, 'FAIL')
            logger.error("第{}用例执行结果:FAIL".format(item.id))
            raise e

    def tearDown(self):
        pass
예제 #24
0
class APITest(unittest.TestCase):
    do_excel = DoExcel(contants.case_file)  # 传入cases.xlsx
    login_cases = do_excel.read('login')  # 一个就够,不需要重复写多个对象
    request = Request()  # 实例化一个对象

    def setUp(self):
        pass

    @unittest.skip("忽略测试,不要运行")  # 暂时不运行此用例
    @data(*login_cases)
    def test_login(self, case):
        print("开始执行第{0}行用例".format(case.case_id))
        # 使用分装好的request来完成请求
        resp = self.request.request(case.method, case.url, case.data)  # 实例对象已移到外面,这里要加self.
        # 将返回结果与期望结果对比
        try:
            self.assertEqual(case.expected, resp.text, 'login error')
            # 一致就写入Excel的结果PASS
            self.do_excel.write_back(case.case_id+1, resp.text, 'PASS')  # 实例对象已放外面,类变量加self.
            print("第{0}行用例执行结果:PASS".format(case.case_id))
        except AssertionError as e:
            self.do_excel.write_back(case.case_id+1, resp.text, 'FAIL')  # 实例对象已放外面,类变量加self.调用
            print("第{0}行用例执行结果:FAIL".format(case.case_id))
            raise e

    register_cases = do_excel.read('register')  # 增加了一个方法

    # mysql = MysqlUtil()  # 实例化对象(进行了一次数据库的连接)
    # sql = "SELECT MAX(MobilePhone) FROM future.member WHERE MobilePhone LIKE '152%';"  # 传一条sql进来
    # max = mysql.fetch_one(sql)[0]  # 找到最大手机号码, 元组里取第1个值
    # print(type(max), max)

    @data(*register_cases)
    def test_register(self, case):

        mysql = MysqlUtil()  # 实例化对象(进行了一次数据库的连接)
        sql = "SELECT MAX(MobilePhone) FROM future.member WHERE MobilePhone LIKE '152%';"  # 传一条sql进来
        max = mysql.fetch_one(sql)[0]  # 找到最大手机号码, 元组里取第1个值

        print("开始执行第{0}行用例".format(case.case_id))
        import json
        data_dict = json.loads(case.data)  # Excel字符串转成字典
        if data_dict['mobilephone'] == '${register_mobile}':  # 判断是否等于标记
            data_dict['mobilephone'] = int(max) + 1  # 将最大手机号码+1 赋值给mobilephone

        # 使用封装好的request来完成请求
        resp = self.request.request(case.method, case.url, data_dict)  # 实例对象已移到外面,这里要加self.
        # 将返回结果与期望结果对比
        try:
            self.assertEqual(case.expected, resp.text, 'register error')
            # 一致就写入Excel的结果PASS,并且
            self.do_excel.write_back(case.case_id+1, resp.text, 'PASS')  # 实例对象已放外面,类变量加self.
            print("第{0}行用例执行结果:PASS".format(case.case_id))
        except AssertionError as e:
            self.do_excel.write_back(case.case_id+1, resp.text, 'FAIL')  # 实例对象已放外面,类变量加self.调用
            print("第{0}行用例执行结果:FAIL".format(case.case_id))
            raise e

    def tearDown(self):
        pass
예제 #25
0
class AddloanTest(unittest.TestCase):
    cases = doexcel.DoExcel(contants.case_file, "addloan").get_data("addloan")
    request = Request()

    def setUp(self):
        pass

    def tearDown(self):
        pass

    @data(*cases)
    def test_addloan(self, case):
        readconfig = ReadConfig()
        pre_url = readconfig.get("api", "pre_url")
        print("开始执行第{}个测试用例:".format(case.case_id))
        resp = self.request.request(method=case.method,
                                    url=pre_url + case.url,
                                    data=case.data)
        doexcels = doexcel.DoExcel(contants.case_file, "addloan")
        try:
            self.assertEqual(case.expected, resp.text)
            doexcels.write_back(row=case.case_id + 2,
                                col=8,
                                value="PASS",
                                sheet_name="addloan")
        except AssertionError as e:
            doexcels.write_back(row=case.case_id + 2,
                                col=8,
                                value="FAIlED",
                                sheet_name="addloan")
        doexcels.write_back(case.case_id + 2,
                            7,
                            resp.text,
                            sheet_name="addloan")
        print(resp.text)
예제 #26
0
 def test_longin(self, case):
     url = getattr(contex, 'url') + case.url
     mylog = MyLog()
     mylog.debug('判断有无初始化的cookies值')
     if hasattr(contex, 'cookies'):
         cookies = getattr(contex, 'cookies')
     else:
         cookies = None
     mylog.debug('获取到的cookies值是:{}'.format(cookies))
     params = json.loads(DoRegex().replace(case.params))
     resp = Request(method=case.method, url=url, data=params, cookies=cookies)
     mylog.info('执行{}的用例'.format(case.title))
     mylog.info('请求数据{}'.format(params))
     if resp.cookies():
         setattr(contex, 'cookies', resp.cookies())
         mylog.info('本次请求获取到的cookies是:{}'.format(resp.cookies()))
     actual = resp.get_txt()
     result = None
     try:
         self.assertEqual(actual, case.expected)
         result = 'PASS'
         mylog.info('执行{}的用例:{}'.format(case.title, result))
     except Exception as e:
         result = 'FAILED'
         mylog.error('执行{}的用例,错误信息是:{}'.format(case.title, e))
         raise e
     finally:
         read.write_result(case.caseid + 1, 7, resp.get_txt())
         read.write_result(case.caseid + 1, 8, result)
         mylog.info('写入测试结果完成')
    def schedule_and_build_instances(self, context, build_requests,
                                     request_specs, image,
                                     admin_password, injected_files,
                                     requested_networks, block_device_mapping):
        index = 0

        for build_request in build_requests:
            request_spec = request_specs[index]

            index += 1

            data = {'build_requests': [build_request],
                    'request_specs': [request_spec],
                    'image': image,
                    'admin_password': admin_password,
                    'injected_files': injected_files,
                    'requested_networks': requested_networks,
                    'block_device_mapping': block_device_mapping}

            req = {"context": context, "data": data,
                   "action": "schedule_and_build_instances"}

            request = Request.fromDict(req)

            self.nova_manager.notify(event_type="SERVER_CREATE",
                                     request=request)
class LoginTest(unittest.TestCase):
    do_excel = DoExcel(contants.case_file)  # 传入cases.xlsx
    cases = do_excel.get_cases('login')
    request = Request()  # 实例化对象

    def setUp(self):
        pass

    @data(*cases)
    def test_login(self,case):
        logger.info("开始执行第{0}用例".format(case.id))
        # 使用封装好的request 来完成请求
        resp = self.request.request(case.method, case.url, case.data)
        # 将返回结果和期望结果进行匹配
        try:
            self.assertEqual(case.expected, resp.text, "login error ")
            # 一致就写入Excel的结果为PASS,并且
            self.do_excel.write_result('login',case.id + 1, resp.text, 'PASS')
            logger.info("第{0}用例执行结果:PASS".format(case.id))
        except AssertionError as e:
            self.do_excel.write_result('login',case.id + 1, resp.text, 'FAIL')
            logger.error("第{0}用例执行结果:FAIL".format(case.id))
            raise e

    def tearDown(self):
        pass
예제 #29
0
def get_task_id(token):

    request = Request()

    method = 'post'
    param = {"task_type": 400, "ignore_sub_task_error": 1}
    para = json.dumps(param)

    url = readconfig.agv_url + '/tasks/task/'
    header = {
        "Content-Type": "application/x-www-form-urlencoded",
        "token": token
    }
    r = request.request(method, url, para, header)
    result = r.json()

    return result['data']['rows'][0]['id']
예제 #30
0
class RegisterTest(unittest.TestCase):
    do_excel = DoExcel(constants.case_file)  # 读取cases.xlsx
    register_cases = do_excel.get_cases('register')
    request = Request()  # 实例化对象

    mysql = MysqlUtil(return_dict=True)
    sql = 'select max(mobilephone) as max_mobilephone from future.member'

    def setUp(self):
        self.max_mobilephone = self.mysql.fetch_one(
            self.sql)['max_mobilephone']

    @data(*register_cases)
    def test_register(self, case):
        logger.info("开始执行第{0}用例".format(case.id))
        import json
        data_dict = json.loads(case.data)
        if data_dict['mobilephone'] == '${register_mobile}':
            data_dict['mobilephone'] = int(
                self.max_mobilephone) + 1  # 数据库中最大手机号+1
        if 'regname' in data_dict.keys():
            regname = data_dict['regname']
        else:
            regname = None
        # print(regname)
        # 使用封装好的request 来完成请求
        resp = self.request.request(case.method, case.url, data_dict)
        # print(resp.json())
        try:
            # 将返回结果和期望结果进行匹配
            self.assertEqual(case.expected, resp.text, 'register error')
            # 一致就写入Excel的结果为Pass
            self.do_excel.write_result('register', case.id + 1, resp.text,
                                       'Pass')
            if resp.json()['msg'] == '注册成功':
                sql = "select * from future.member where mobilephone = '{0}'".format(
                    data_dict['mobilephone'])
                result = self.mysql.fetch_all(sql)
                # 首先判断是否有成功插入数据
                self.assertEqual(1, len(result), '注册成功时,仅在数据库中插入一条数据')
                # 判断注册成功余额应该是0
                self.assertEqual(0, result[0]['LeaveAmount'], '注册成功后,初始余额应该是0')
                # 判断regname
                if regname:
                    self.assertEqual(regname, result[0]['RegName'])
                else:
                    self.assertEqual('小蜜蜂', result[0]['RegName'])
            logger.info("第{0}用例执行结果:PASS".format(case.id))
        except AssertionError as e:
            # 不一致就写入Excel的结果为Fail,并抛出异常
            self.do_excel.write_result('register', case.id + 1, resp.text,
                                       'Fail')
            logger.error("第{0}用例执行结果:FAIL".format(case.id))
            raise e

    @classmethod
    def tearDownClass(cls):
        cls.mysql.close()
class TestApiMethod(unittest.TestCase):
    '这是测试接口的类'
    do_excel = DoExcel(contants.excel_file)  # 传入excel
    cases_login = do_excel.read_excel("login")
    cases_register = do_excel.read_excel("register")

    request = Request()

    def setUp(self):
        # self.write_register = do_excel.write_excel("register")  # 创建一个对象写入
        # self.write_register = do_excel.write_excel("login")  # 创建一个对象写入
        my_log.info("开始执行用例")

    def tearDown(self):
        my_log.info("用例执行结束")

    @data(*cases_register)
    def test_register(self, case):  # 测试注册
        my_log.info("开始执行第{}条用例: {}".format(case.case_id, case.title))
        my_log.info('url:{}'.format(case.url))
        my_log.info('data:{}'.format(case.data))
        my_log.info('method:{}'.format(case.method))
        my_log.info('expected:{}'.format(case.expected))
        result = self.request.request(case.method, case.url, case.data)
        try:
            self.assertEqual(case.expected, result.text)
            self.do_excel.write_excel(case.case_id + 1, result.text,
                                      "Pass")  # 写入测试实际结果
            # TestResult = "Pass"
        except AssertionError as e:
            self.do_excel.write_excel(case.case_id + 1, result.text,
                                      "Failed")  # 写入测试实际结果
            # TestResult = "Failed"
            my_log.error("断言出错了".format(e))
            raise e
        # finally:
        #     self.do_excel.write_excel(case.case_id+1, result.text, TestResult)  # 写入测试实际结果
        #     my_log.info('注册的结果:{}'.format(result))

    @data(*cases_login)
    def test_login(self, case):  # 测试登陆
        my_log.info("开始执行第{}条用例: {}".format(case.case_id, case.title))
        my_log.info('url:{}'.format(case.url))
        my_log.info('data:{}'.format(case.data))
        my_log.info('method:{}'.format(case.method))
        my_log.info('expected:{}'.format(case.expected))
        result = self.request.request(case.method, case.url, case.data)
        try:
            self.assertEqual(case.expected, result.text)
            self.do_excel.write_excel(case.case_id + 1, result.text,
                                      "Pass")  # 写入测试实际结果
            # TestResult = "Pass"
        except AssertionError as e:
            self.do_excel.write_excel(case.case_id + 1, result.text,
                                      "Failed")  # 写入测试实际结果
            # TestResult = "Failed"
            my_log.error("断言出错了".format(e))
            raise e
예제 #32
0
def save_img(url):
    """
    save image
    """
    try:
        image = Request.request('GET', url)
        if image.content:
            with open('{}/{}.jpg'.format(PATH, hashlib.md5(url).hexdigest()), 'wb') as f:
                for chunk in image.iter_content(chunk_size=1024):
                    f.write(chunk)
    except Exception as e:
        logger.error('save image error, url [{}], error message [{}]'.format(url, e))
    def build_instances(self, context, instances, image, filter_properties,
                        admin_password, injected_files, requested_networks,
                        security_groups, block_device_mapping=None,
                        legacy_bdm=True):
        for instance in instances:
            data = {'instances': [instance],
                    'image': image,
                    'filter_properties': filter_properties,
                    'admin_password': admin_password,
                    'injected_files': injected_files,
                    'requested_networks': requested_networks,
                    'security_groups': security_groups,
                    'block_device_mapping': block_device_mapping,
                    'legacy_bdm': legacy_bdm}

            req = {"context": context, "data": data,
                   "action": "build_instances"}
            try:
                request = Request.fromDict(req)

                self.nova_manager.notify(event_type="SERVER_CREATE",
                                         request=request)
            except Exception as ex:
                LOG.info(ex)
    def run(self):
        LOG.info("Worker %s running!" % self.name)
        queue_items = []
        last_release_time = SharedQuota.getLastReleaseTime()

        while not self.exit and not self.queue.isClosed():
            try:
                if last_release_time < SharedQuota.getLastReleaseTime():
                    last_release_time = SharedQuota.getLastReleaseTime()

                    while queue_items:
                        self.queue.restore(queue_items.pop(0))

                    for project in self.project_manager.getProjects():
                        for user in project.getUsers():
                            self.queue.updatePriority(user)

                if len(queue_items) >= self.backfill_depth:
                    SharedQuota.wait()
                    continue

                queue_item = self.queue.dequeue(block=False)

                if queue_item is None:
                    if self.queue.getSize():
                        SharedQuota.wait()
                        continue
                    else:
                        queue_item = self.queue.dequeue(block=True)

                if queue_item is None:
                    continue

                request = Request.fromDict(queue_item.getData())
                user_id = request.getUserId()
                prj_id = request.getProjectId()
                context = request.getContext()
                server = request.getServer()
                server_id = server.getId()
                quota = None

                try:
                    s = self.nova_manager.getServer(server_id, detail=True)

                    if s.getState() != "building":
                        # or server["OS-EXT-STS:task_state"] != "scheduling":
                        self.queue.delete(queue_item)
                        continue
                except SynergyError as ex:
                    LOG.warn("the server %s is not anymore available!"
                             " (reason=%s)" % (server_id, ex))
                    self.queue.delete(queue_item)

                    continue

                project = self.project_manager.getProject(id=prj_id)

                if not project:
                    raise SynergyError("project %r not found!" % prj_id)

                quota = project.getQuota()
                blocking = False

                if server.isEphemeral() and not SharedQuota.isEnabled():
                    blocking = True

                if quota.allocate(server, blocking=blocking):
                    found = False

                    try:
                        km = self.keystone_manager
                        trust = km.getTrust(context["trust_id"])
                        token = trust.getToken(km.getToken().getId())

                        context["auth_token"] = token.getId()
                        context["user_id"] = token.getUser().getId()
                    except SynergyError as ex:
                        LOG.error("error on getting the token for server "
                                  "%s (reason=%s)" % (server.getId(), ex))
                        raise ex

                    try:
                        self.nova_manager.buildServer(request)

                        LOG.info("building server %s user_id=%s prj_id=%s quo"
                                 "ta=shared" % (server_id, user_id, prj_id))

                        found = True
                    except Exception as ex:
                        LOG.error("error on building the server %s (reason=%s)"
                                  % (server.getId(), ex))

                    if found:
                        self.queue.delete(queue_item)
                    else:
                        quota.release(server)
                        queue_items.append(queue_item)
                else:
                    queue_items.append(queue_item)

            except Exception as ex:
                LOG.error("Exception has occured", exc_info=1)
                LOG.error("Worker %s: %s" % (self.name, ex))

                self.queue.delete(queue_item)

        LOG.info("Worker %s destroyed!" % self.name)
예제 #35
0
def fetch(url):
    """
    fetch html
    """
    html = Request.request('GET', url).text
    parse_html(html)
예제 #36
0
import random
import sys
import os

params={}
params['Data'] = [{'dimensions':{'lanip':myaddr},'value':mem_usage,'metricName':metricName}]
print params
params['Nonce'] = random.randint(1, sys.maxint)
params['Timestamp'] = currentTime
params['Region'] = region
params['Namespace'] = namespace
params['SecretId'] = secretId
print params

sys.path.append(os.path.split(os.path.realpath(__file__))[0] + os.sep)
print sys.path
from common.request import Request

request = Request(secretId, secretKey)
url = request.generateUrl(requestHost, requestUri , params)
print 'end url: ' + url

import urllib2
req = urllib2.Request(url)
print req

res_data = urllib2.urlopen(req)
res = res_data.read()
print res
예제 #37
0
 def generateUrl(self, action, params):
     self._checkParams(action, params)
     request = Request(self.secretId, self.secretKey)
     return request.generateUrl(self.requestHost, self.requestUri, self._params, self.method)
예제 #38
0
 def call(self, action, params, files = {}):
     self._checkParams(action, params)
     request = Request(self.secretId, self.secretKey)
     return request.send(self.requestHost, self.requestUri, self._params, files, self.method, self.debug)
예제 #39
0
 def test_some_method(self):
     request = Request()
     self.assertEqual(request.some_method(2, 2), 4)