python接口自动化多环境配置文件的切换, jenkins传参切换环境等

第一种:通过yaml文件切换配置文件

• 因有不同环境的配置文件,需要可以通过一个参数直接切换不同环境
• 通过主配置文件application.yaml ,切换环境

profiles:
	active: TEST        #切换配置文件TEST ,GD,QH,FJ

• 不同环境的配置文件,如下application_dev.yaml文件,可根据需要自定义修改:

imgTest:
  base_url: 
  port: 
  data: test_data1.xlsx   #用例文件

• 读取yaml文件数据代码,通过@property装饰方法后,在自动化测试中直接调用需要的参数即可

#confingread.py
import os
import yaml

class yamlConfig:
    DEV = 'DEV'           #开发环境
    TEST = 'TEST'		#测试环境
    PRODGD = 'GD'	#正式环境1
  
    _instance = None    # 保存实例化对象
	
	 # 可以实例化时传入环境变量或通过读取配置文件获取
    def __init__(self, env=None, path='config'):
    	'''
    		env 未传env参数,默认读取application.yaml文件获取变量
    	'''
        # 项目根目录
        self.root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
        self.path = f'{self.root}/{path}'
		#获取读取设置环境的yaml文件
        self.__conf = self.__load_env(f'{self.path}/application.yaml')
        # print(self.__conf['spring']['profiles']['active'])
        # 获取环境变量
        if env is not None:
            self.__env = env
        else:
            self.__env = self.__conf['profiles']['active']

        # 根据环境变量读取对应配置文件
        if self.__env == yamlConfig.DEV:
            self.__conf = self.__load_env(f'{self.path}/application_dev.yaml')

        elif self.__env == yamlConfig.TEST:
            self.__conf = self.__load_env(f'{self.path}/application_test.yaml')

        elif self.__env == yamlConfig.PRODGD:
            self.__conf = self.__load_env(f'{self.path}/application_gd.yaml')

        else:
            raise EnvironmentError('Environment error')

    # 单例模式
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = object.__new__(cls)
        return cls._instance

    # 读取yaml文件
    @staticmethod
    def __load_env(env_file_name):
        file = open(env_file_name, 'r', encoding='utf-8')
        yml = yaml.safe_load(file)
        return yml

    def __str__(self):
        return f'读取的数据:{self.__conf}'

    # 获取环境变量
    @property
    def env(self):
        return self.__env

    # 是否是test环境
    @property
    def is_test(self):
        return yamlConfig.TEST == self.env

    # 获取图片配置
    @property
    def imgtest(self):
        return self.__conf['imgTest']

    # 图片base_url 
    @property
    def get_img_base_url(self):
        return self.imgtest['base_url']

    # 获取图片url端口
    @property
    def get_img_port(self):
        return self.imgtest['port']


    # 获取配置中excel用例名
    @property
    def get_test_data_config(self):
        return self.imgtest['data']

    # 项目根目录
    @property
    def get_project_dir(self):
        return self.root

    # 用例路径
    @property
    def get_excel_data_dir(self):
        return os.path.join(self.get_project_dir, 'data', self.get_test_data_config)

    # 测试报告目录
    @property
    def get_report_dir(self):
        return os.path.join(self.get_project_dir, 'report')

    # 创建allure报告环境配置文件
    def create_allure_env_file(self):
        file_path = f'{self.get_report_dir}/tmp/environment.properties'
        with open(file_path, 'w') as f:
            f.write(f'ENV={self.env}')
        f.close()


if __name__ == '__main__':
    conf = yamlConfig()
    conf1 = yamlConfig()
    print(id(conf))
    print(id(conf1))
    print(conf.get_project_dir, conf.get_bucket_name, conf.get_img_base_url)
    print(type(conf.get_img_url))

第二种通过pytest 传参切换环境

• pytest_addoption 可以让用户注册一个自定义的命令行参数

#conftest.py
import os

import pytest
import yaml
from common.logger import logger

# 注册自定义参数到配置对象
def pytest_addoption(parser):
    parser.addoption("--env", action="store",
                     default="TEST",
                     help="将命令行参数 ’--env' 添加到 pytest 配置中")

# 从配置对象中读取自定义参数的值
@pytest.fixture(scope="session")
def get_env(request):
    logger.info('从配置对象读取自定义参数')
    return request.config.getoption("--env")

# 将自定义参数的值写入配置文件
@pytest.fixture(scope="session",autouse=True)
def set_env(get_env):
    logger.info('自定义参数写入配置文件')
    root = os.path.dirname(os.path.abspath(__file__))
    with open(root+"/config/application.yaml") as f:
        ym = yaml.load(f)
        ym['profiles']['active'] = get_env
    with open(root+"/config/application.yaml", "w") as f:
        yaml.dump(ym,f)
    print('\n --env:', get_env)


if __name__ == "__main__":
    pytest.main(['-s', f'--env=DEV'])

第三种 通过命令行参数传参

 # 获取命令行参数
    @staticmethod
    def args_get():
        evn = (Common.DEV, Common.TEST, Common.PRODFJ, Common.PRODQH, Common.PRODGD)
        print('获取命令行参数')
        parser = argparse.ArgumentParser()
        parser.add_argument("--evn", )
        args = parser.parse_args()

        param = vars(args)

        v = {}
        for key, value in param.items():
            # 判断命令行传的参数是否符合
            if value in evn:
                v[key] = value
            else:
                print(f'所传参数{value}错误,不改变环境变量')
                v[key] = None

        print(f'args参数:{v}')
        return v

    # 将命令行参数写入配置文件
    def set_evn(self, args):
        print(f'判断命令行参数是否为空{args}')
        if args.get('evn') is not None:
            print(f'开始将命令行参数写入配置文件:{args}')
            with open(self.get_project_dir + "/config/application.yaml") as f:
                ym = yaml.load(f, Loader=yaml.FullLoader)
                ym['profiles']['active'] = args.get('evn')

            with open(self.get_project_dir + "/config/application.yaml", "w") as f:
                yaml.dump(ym, f)
            print('成功写入 --env:', args.get('evn'))

• 我是将方法写在公共模块中,然后再用例执行前调用
• 然后通过jenkins 参数化的方式传参切换环境

from common.com import com
from common.logger import Log
import pytest


if __name__ == "__main__":
    print('程序入口 runtest.py')
    # 检测是否存在上月日志
    Log().clean_log()

    # 检查命令行是否传参,有写入配置文件
    com.set_evn(com.args_get())

    # 获取报告dir
    reportDir = com.get_report_dir
    pytest.main(["-sq", "--alluredir", reportDir + "/tmp", '--clean-alluredir', f'--junitxml={reportDir + "/results.xml"}'])

    # 在allure中生成环境信息文件
    com.create_allure_env_file()

推荐----对上面的修改

在配置文件读取代码中, 获取环境信息

• .从命令行获取环境参数,如果为空,则获取配置文件中的环境参数 —参考下面获取环境信息代码
• .通过环境信息选择对应配置文件,如配置文件名为 confing_evn.yaml ,其中evn是环境信息,根据传入的不同获取不同的文件

class Config:
    def __init__(self):
        # 项目根目录
        self.root = self.get_project_root

        # config 配置文件路径
        config_path = f'{self.root}/config/'
        # 命令行获取环境信息
        args_evn = self.args_get

        # 获取环境信息
        if args_evn.get('env') is not None:
            # 命令行参数不为空时获取
            self.__env = args_evn.get('env').lower()
            print(f'读取命令行所传变量----------------{self.__env}')
        else:
            # 获取环境信息
            self.__conf_evn = common.load_yaml(config_path + 'config.yaml')
            self.__env = self.__conf_evn['env']

        # 通过环境信息选择对应配置文件
        try:
            self.file_name = config_path + f'config_{self.__env}.yaml'
            self.config_data = self.load_config(self.file_name)
            print(f'read_config.py中的配置数据:{self.config_data}')
        except FileNotFoundError:
            raise FileNotFoundError(f'{self.__env}参数错误,找不到配置文件')

    @property
    def get_env(self):
        return self.__env