Python get_xls Exemples

Exemple #1

# -*- coding:utf-8 -*-
import paramunittest
import unittest
import ddt
import random
from commons import common, Get_excel
from commons import DB_config_Oracle
import requests
from xml.sax import saxutils

# Case_xls = Get_excel.read_casefile_2("Billingrules.xlsx", "Billingrules")
# case=[['querynumber', 'post', '0', '{"current":1,"bh":"20200807151805","size":10}', '0', '0000', '20200807151805'], ['querytype', 'post', '0', '{"current":1,"gzmc":"无照经营","qtbm":"","size":10}', '0', '0000', '无照经营游商']]

Case_xls = common.get_xls("gzfxCase.xlsx", "getgzsjlist")


@paramunittest.parametrized(*Case_xls)
class testlist(unittest.TestCase):
    def setParameters(self, a, b, c, d, e, f, g):
        self.a = a
        self.b = b
        self.c = c
        self.d = d
        self.e = e
        self.f = f
        self.g = g

    @classmethod
    def setUpClass(cls) -> None:
        print('setUpClass')

Exemple #2

Fichier : testUpdatePassword.py Projet : qigemingzijiuzhemenan/interfaceTest

import unittest
import paramunittest
import readConfig as readConfig
from commons import configHttp
from commons import businessCommon
from commons import common
from commons.Log import MyLog

localReadConfig = readConfig.ReadConfig()
localConfigHttp = configHttp.ConfigHttp()
localUpdatePassword_xls = common.get_xls("userCase.xlsx", "updatePassword")


@paramunittest.parametrized(*localUpdatePassword_xls)
class UpdatePassword(unittest.TestCase):
    def setParameters(self, case_name, method, token, old_password, password,
                      password_confirm, result, code, msg):
        """
        set parameters
        :param case_name:
        :param method:
        :param token:
        :param old_password:
        :param password:
        :param password_confirm:
        :param result:
        :param code:
        :param msg:
        :return:
        """
        self.case_name = str(case_name)

Exemple #3

import unittest
import paramunittest
import readConfig as readConfig
from commons import Log as Log
from commons import common
from commons import configHttp as ConfigHttp

deleteAddress_xls = common.get_xls("userCase.xlsx", "deleteAddress")
localReadConfig = readConfig.ReadConfig()
configHttp = ConfigHttp.ConfigHttp()


@paramunittest.parametrized(*deleteAddress_xls)
class DeleteAddress(unittest.TestCase):
    def setParameters(self, case_name, method, address_id, result, code, msg):
        """
        set params
        :param case_name:
        :param method:
        :param address_id:
        :param code:
        :param result:
        :param msg:
        :return:
        """
        self.case_name = str(case_name)
        self.method = str(method)
        self.address_id = str(address_id)
        self.code = str(code)
        self.result = str(result)
        self.msg = str(msg)

Exemple #4

Fichier : testAddAddress.py Projet : qigemingzijiuzhemenan/interfaceTest

import unittest
import paramunittest
import readConfig as readConfig
from commons import Log as Log
from commons import common
from commons import configHttp as ConfigHttp
from commons import businessCommon

addAddress_xls = common.get_xls("userCase.xlsx", "addAddress")
localReadConfig = readConfig.ReadConfig()
configHttp = ConfigHttp.ConfigHttp()


@paramunittest.parametrized(*addAddress_xls)
class AddAddress(unittest.TestCase):
    def setParameters(self, case_name, method, token, sex, fname, lname, tel,
                      standby_tel, address1, address2, city, state, postcode,
                      country_id, tax_number, company, fax, is_default, result,
                      code, msg):
        """
        set params
        :param case_name:
        :param method:
        :param token:
        :param sex:
        :param fname:
        :param lname:
        :param tel:
        :param standby_tel:
        :param address1:
        :param address2:

Exemple #5

Fichier : testLogout.py Projet : qigemingzijiuzhemenan/interfaceTest

import unittest
import paramunittest
import readConfig as ReadConfig
from commons.Log import MyLog
from commons import common
from commons import configHttp
from commons import businessCommon

localReadConfig = ReadConfig.ReadConfig()
localConfigHttp = configHttp.ConfigHttp()
localLogout_xls = common.get_xls("userCase.xlsx", "logout")


@paramunittest.parametrized(*localLogout_xls)
class Logout(unittest.TestCase):

    def setParameters(self, case_name, method, token, result, code, msg):
        """
        set parameters
        :param case_name:
        :param method:
        :param token:
        :param result:
        :param code:
        :param msg:
        :return:
        """
        self.case_name = str(case_name)
        self.method = str(method)
        self.token = str(token)
        self.result = str(result)

Exemple #6

Fichier : testRegisterQuick.py Projet : qigemingzijiuzhemenan/interfaceTest

import readConfig as readConfig
import unittest
import paramunittest
from commons.Log import MyLog
from commons import configHttp
from commons import common
from commons import configMysqlDB

localRegisterQuick_xls = common.get_xls("userCase.xlsx", "registerquick")
localReadConfig = readConfig.ReadConfig()
localConfigHttp = configHttp.ConfigHttp()
localConfigDB = configMysqlDB.MyDB()


@paramunittest.parametrized(*localRegisterQuick_xls)
class RegisterQuick(unittest.TestCase):
    def setParameters(self, case_name, method, token, email, result, code,
                      msg):
        """
        set parameters
        :param case_name:
        :param method:
        :param token:
        :param email:
        :param result:
        :param code:
        :param msg:
        :return:
        """
        self.case_name = str(case_name)
        self.method = str(method)

Exemple #7

import unittest
import paramunittest
import readConfig as readConfig
from commons.Log import MyLog
from commons import common
from commons import configHttp

localGenerate_xls = common.get_xls("userCase.xlsx", "generate")
localConfigHttp = configHttp.ConfigHttp()
localReadConfig = readConfig.ReadConfig()


@paramunittest.parametrized(*localGenerate_xls)
class Generate(unittest.TestCase):
    def setParameters(self, case_name, method, result, code, msg):
        """
        set parameters
        :param case_name:
        :param method:
        :param result:
        :param code:
        :param msg:
        :return:
        """
        self.case_name = str(case_name)
        self.method = str(method)
        self.result = str(result)
        self.code = str(code)
        self.msg = str(msg)
        self.response = None
        self.info = None

Exemple #8

import unittest
import paramunittest
import readConfig as readConfig
from commons import Log as Log
from commons import common
from commons import configHttp as ConfigHttp
from commons import businessCommon

addressList_xls = common.get_xls("userCase.xlsx", "getAddressList")
localReadConfig = readConfig.ReadConfig()
configHttp = ConfigHttp.ConfigHttp()
info = {}


@paramunittest.parametrized(*addressList_xls)
class GetAddressList(unittest.TestCase):
    def setParameters(self, case_name, method, token, result, code, msg):
        """
        set params
        :param case_name:
        :param method:
        :param token:
        :param result:
        :param code:
        :param msg:
        :return:
        """
        self.case_name = str(case_name)
        self.method = str(method)
        self.token = str(token)
        self.result = str(result)

Exemple #9

Fichier : testRegister.py Projet : qigemingzijiuzhemenan/interfaceTest

import readConfig as readConfig
from commons.Log import MyLog
from commons import configHttp
from commons import common
import unittest
import paramunittest
from commons import configMysqlDB

register_xls = common.get_xls("userCase.xlsx", "register")
localConfigHttp = configHttp.ConfigHttp()
localReadConfig = readConfig.ReadConfig()
localConfigDB = configMysqlDB.MyDB()


@paramunittest.parametrized(*register_xls)
class Register(unittest.TestCase):
    def setParameters(self, case_name, method, token, email, password,
                      confirmpwd, result, code, msg):
        """
        set parameters
        :param case_name:
        :param method:
        :param token:
        :param email:
        :param password:
        :param confirmpwd:
        :param result:
        :param code:
        :param msg:
        :return:
        """

Exemple #10

import readConfig as readConfig
import unittest
import paramunittest
from commons.Log import MyLog
from commons import configHttp
from commons import common
from commons import DB_config_Oracle

Case_xls = common.get_xls("governCase.xlsx", "queryFxddFptj")
localReadConfig = readConfig.ReadConfig()
localConfigHttp = configHttp.ConfigHttp()
localConfigDB = DB_config_Oracle.DB()


@paramunittest.parametrized(*Case_xls)
class testqueryFxddFptj(unittest.TestCase):
    def setParameters(self, case_name, method, cookie, data, result, code,
                      msg):
        """
        set parameters
        :param case_name:
        :param method:
        :param token:
        :param data:
        :param result:
        :param code:
        :param msg:
        :return:
        """
        self.case_name = str(case_name)
        self.method = str(method)

Exemple #11

Fichier : testLoginFB.py Projet : qigemingzijiuzhemenan/interfaceTest

import unittest
import paramunittest
import readConfig as readConfig
from commons.Log import MyLog
from commons import common
from commons import configHttp

localReadConfig = readConfig.ReadConfig()
localConfigHttp = configHttp.ConfigHttp()
localLoginFB_xls = common.get_xls("userCase.xlsx", "loginFB")


@paramunittest.parametrized(*localLoginFB_xls)
class LoginFB(unittest.TestCase):
    def setParameters(self, case_name, method, token, email, facebook_id,
                      fbtoken, invite_agency, code, msg):
        """
        set parameters
        :param case_name:
        :param method:
        :param token:
        :param email:
        :param facebook_id:
        :param fbtoken:
        :param invite_agency:
        :param code:
        :param msg:
        :return:
        """
        self.case_name = str(case_name)
        self.method = str(method)

Exemple #12

import unittest
import paramunittest
import readConfig as readConfig
from commons import common
from commons import configHttp
from commons.Log import MyLog
from commons import businessCommon

localReadConfig = readConfig.ReadConfig()
localConfigHttp = configHttp.ConfigHttp()
localLogin_xls = common.get_xls("userCase.xlsx", "login")
localAccountSetting_xls = common.get_xls("userCase.xlsx", "accountSetting")


@paramunittest.parametrized(*localAccountSetting_xls)
class AccountSetting(unittest.TestCase):
    def setParameters(self, case_name, method, token, sex, telephone, nickname,
                      birthday, country_id, result, code, msg):
        """
        set params
        :param case_name:
        :param method:
        :param token:
        :param sex:
        :param telephone:
        :param nickname:
        :param birthday:
        :param country_id:
        :param result:
        :param code:
        :param msg:

Exemple #13

import unittest
import paramunittest
import readConfig as readConfig
from commons import Log as Log
from commons import common
from commons import configHttp as ConfigHttp

login_xls = common.get_xls("userCase.xlsx", "login")
localReadConfig = readConfig.ReadConfig()
configHttp = ConfigHttp.ConfigHttp()
info = {}


@paramunittest.parametrized(*login_xls)
class Login(unittest.TestCase):
    # def setParameters(self, case_name, method, token, email, password, result, code, msg):
    def setParameters(self, case_name, method, token, email, password, result, code, msg):
        """
        set params
        :param case_name:
        :param method:
        :param token:
        :param email:
        :param password:
        :param result:
        :param code:
        :param msg:
        :return:
        """
        self.case_name = str(case_name)
        self.method = str(method)

Exemple #14

# -*- coding: utf-8 -*-
import readConfig as readConfig
import unittest
import paramunittest
from commons.Log import MyLog
from commons import common, get_md5date
import time

Case_xls = common.get_xls("Billing_rulesCase.xlsx", "Billing_rules")
localReadConfig = readConfig.ReadConfig()
localConfigHttp = common.ConfigHttp()
localConfigDB = common.DB_Mysql()


@paramunittest.parametrized(*Case_xls)
class testBilling_rules(unittest.TestCase):
    def setParameters(self, case_name, method, carnumber, berthcode,
                      vehicletype, carproperty, startime, endtime, pay,
                      message):
        """
        set parameters

        """
        self.case_name = str(case_name)
        self.method = str(method)
        self.carnumber = str(carnumber)
        self.berthcode = str(berthcode)
        self.vehicletype = '1' if vehicletype == '工作日' else vehicletype == '非工作日' '2'
        self.carproperty = '1' if carproperty == '小型车' else carproperty == '大型车' '2'
        self.startime = common.get_times(str(startime))
        self.endtime = common.get_times(str(endtime))

Exemple #15

Fichier : testGetProductInfo.py Projet : qigemingzijiuzhemenan/interfaceTest

import unittest
import paramunittest
from commons import common
from commons.Log import MyLog
import readConfig as readConfig
from commons import configHttp as configHttp

productInfo_xls = common.get_xls("productCase.xlsx", "getProductInfo")
localReadConfig = readConfig.ReadConfig()
localConfigHttp = configHttp.ConfigHttp()


@paramunittest.parametrized(*productInfo_xls)
class ProductInfo(unittest.TestCase):
    def setParameters(self, case_name, method, token, goods_id, result, code,
                      msg):
        """
        set params
        :param case_name:
        :param method:
        :param token:
        :param goods_id:
        :param result:
        :param code:
        :param msg:
        :return:
        """
        self.case_name = str(case_name)
        self.method = str(method)
        self.token = str(token)
        self.goodsId = str(goods_id)

Exemple #16

Fichier : testUploadImg.py Projet : qigemingzijiuzhemenan/interfaceTest

import os
import unittest
import paramunittest
import readConfig as readConfig
from commons import common
from commons import configHttp
from commons import businessCommon
from commons.Log import MyLog

localUploadImg_xls = common.get_xls("userCase.xlsx", "uploadImg")
localReadConfig = readConfig.ReadConfig()
localConfigHttp = configHttp.ConfigHttp()


@paramunittest.parametrized(*localUploadImg_xls)
class UploadImg(unittest.TestCase):
    def setParameters(self, case_name, method, token, whole, file, result,
                      code, msg):
        """
        set param
        :param case_name:
        :param method:
        :param token:
        :param whole:
        :param file:
        :param result:
        :param code:
        :param msg:
        :return:
        """
        self.case_name = str(case_name)