1. 动态添加认证处理

1. class AuthMeta(type):

2. def __new__(cls, name, bases, dct):

3. if "send_request" in dct:

4. original_send_request = dct["send_request"]

5. def new_send_request(self, *args, **kwargs):

6. headers = kwargs.get("headers", {})

7. headers["Authorization"] = self.get_token()

8. kwargs["headers"] = headers

9. return original_send_request(self, *args, **kwargs)

10. dct["send_request"] = new_send_request

11. return super().__new__(cls, name, bases, dct)

12. class BaseAPI(metaclass=AuthMeta):

13. def get_token(self):

14. return "your_token_here"

15. def send_request(self, method, url, **kwargs):

16. print(f"Sending {method} request to {url}...")

17. # 实际发送请求的逻辑省略

18. class MyAPI(BaseAPI):

19. def some_test(self):

20. self.send_request("GET", "https://api.example.com/data")

21. MyAPI().some_test()

此元类自动向所有继承自BaseAPI的类添加认证头。

2. 配置管理

1. class ConfigurableMeta(type):

2. def __new__(cls, name, bases, dct):

3. config = dct.get("config", {})

4. for key, value in config.items():

5. setattr(cls, key, property(lambda self, k=key: self._config[k]))

6. dct["_config"] = config

7. return super().__new__(cls, name, bases, dct)

8. class APIConfig(metaclass=ConfigurableMeta):

9. config = {

10. "base_url": "https://api.example.com",

11. "timeout": 5

12. }

13. class TestAPI(APIConfig):

14. def test_endpoint(self):

15. print(f"Testing {self.base_url}/endpoint...")

16. TestAPI().test_endpoint()

元类用于自动管理API配置，使其成为类的属性。

3. 请求日志记录

1. class LoggingMeta(type):

2. def __new__(cls, name, bases, dct):

3. if "send_request" in dct:

4. original_send_request = dct["send_request"]

5. def new_send_request(self, *args, **kwargs):

6. print(f"Logging request to {args[1]}...")

7. return original_send_request(self, *args, **kwargs)

8. dct["send_request"] = new_send_request

9. return super().__new__(cls, name, bases, dct)

10. class LoggableAPI(metaclass=LoggingMeta):

11. def send_request(self, method, url, **kwargs):

12. print(f"{method} request sent to {url}")

13. LoggableAPI().send_request("GET", "https://api.example.com/log-test")

此元类自动在每个请求前添加日志记录。

4. 自动添加异常处理

1. class ExceptionHandlingMeta(type):

2. def __new__(cls, name, bases, dct):

3. for attr_name in dct:

4. attr = dct[attr_name]

5. if callable(attr):

6. def wrap_in_exception_handling(func):

7. def handler(*args, **kwargs):

8. try:

9. return func(*args, **kwargs)

10. except Exception as e:

11. print(f"Error in {func.__name__}: {e}")

12. return handler

13. dct[attr_name] = wrap_in_exception_handling(attr)

14. return super().__new__(cls, name, bases, dct)

15. class SafeAPI(metaclass=ExceptionHandlingMeta):

16. def risky_operation(self):

17. raise ValueError("Something went wrong.")

18. api = SafeAPI()

19. api.risky_operation()

元类为所有方法添加通用异常处理逻辑。

5. 动态生成测试用例

1. class TestCaseMeta(type):

2. def __new__(cls, name, bases, dct):

3. tests = dct.get("tests", [])

4. for test_name, test_func in tests.items():

5. def wrapper(self):

6. return test_func(self)

7. wrapper.__name__ = test_name

8. dct[test_name] = wrapper

9. return super().__new__(cls, name, bases, dct)

10. class TestSuite(metaclass=TestCaseMeta):

11. tests = {

12. "test_case_1": lambda self: print("Executing test case 1"),

13. "test_case_2": lambda self: print("Executing test case 2")

14. }

15. suite = TestSuite()

16. suite.test_case_1()

17. suite.test_case_2()

元类根据字典动态生成测试用例方法。

6. 环境切换

1. class EnvironmentMeta(type):

2. def __new__(cls, name, bases, dct):

3. env = dct.get("environment", "production")

4. dct["_env"] = env

5. return super().__new__(cls, name, bases, dct)

6. class EnvironmentAwareAPI(metaclass=EnvironmentMeta):

7. def get_base_url(self):

8. if self._env == "production":

9. return "https://api.example.com"

10. elif self._env == "staging":

11. return "https://staging-api.example.com"

12. else:

13. return "Invalid environment"

14. api = EnvironmentAwareAPI(environment="staging")

15. print(api.get_base_url())

元类用于根据环境配置返回不同的基础URL。

7. 自动参数验证

1. class ParamValidationMeta(type):

2. def __new__(cls, name, bases, dct):

3. for method_name, method in dct.items():

4. if callable(method) and method_name.startswith("test_"):

5. param_names = method.__code__.co_varnames[:method.__code__.co_argcount]

6. for param in param_names:

7. def validate_param(func, param_name):

8. def wrapper(self, *args, **kwargs):

9. if param_name not in kwargs or not kwargs[param_name]:

10. raise ValueError(f"{param_name} cannot be empty")

11. return func(self, *args, **kwargs)

12. return wrapper

13. dct[method_name] = validate_param(method, param)

14. return super().__new__(cls, name, bases, dct)

15. class ValidatedTests(metaclass=ParamValidationMeta):

16. def test_with_params(self, required_param):

17. print(f"Running test with {required_param}")

18. tests = ValidatedTests()

19. tests.test_with_params(required_param="value") # 正常运行

20. # tests.test_with_params() # 这将引发错误

元类为测试方法添加参数验证逻辑。

8. 接口版本控制

1. class VersionedMeta(type):

2. def __new__(cls, name, bases, dct):

3. version = dct.get("version", "v1")

4. for method_name in dct:

5. if method_name.startswith("api_"):

6. def add_version_to_url(func):

7. def wrapper(self, *args, **kwargs):

8. url = func(self, *args, **kwargs)

9. return f"/{version}{url}"

10. return wrapper

11. dct[method_name] = add_version_to_url(dct[method_name])

12. return super().__new__(cls, name, bases, dct)

13. class VersionedAPI(metaclass=VersionedMeta):

14. version = "v2"

15. def api_endpoint(self, endpoint):

16. return f"/endpoint/{endpoint}"

17. api = VersionedAPI()

18. print(api.api_endpoint("data")) # 输出: /v2/endpoint/data

元类根据版本控制API路径。

9. 响应验证器注册

1. class ResponseValidatorsMeta(type):

2. def __new__(cls, name, bases, dct):

3. validators = dct.get("validators", [])

4. for validator_name in validators:

5. def register_validator(self, validator_name=validator_name):

6. return getattr(self, validator_name)

7. dct[f"validate_{validator_name}"] = register_validator

8. return super().__new__(cls, name, bases, dct)

9. class ValidatorsAPI(metaclass=ResponseValidatorsMeta):

10. validators = ["check_status_code", "check_response_format"]

11. def check_status_code(self):

12. print("Checking status code...")

13. def check_response_format(self):

14. print("Checking response format...")

15. api = ValidatorsAPI()

16. api.validate_status_code()

17. api.validate_response_format()

元类自动为定义的验证方法生成调用接口。

10. 依赖注入

1. class DependencyInjectionMeta(type):

2. def __new__(cls, name, bases, dct):

3. dependencies = dct.get("dependencies", {})

4. for dep_name, dep_class in dependencies.items():

5. instance = dep_class()

6. dct[dep_name.lower()] = instance

7. return super().__new__(cls, name, bases, dct)

8. class BaseService:

9. pass

10. class InjectedService(metaclass=DependencyInjectionMeta):

11. dependencies = {"base_service": BaseService}

12. service = InjectedService()

13. print(service.base_service) # 输出实例化的BaseService对象

元类用于自动注入依赖服务，简化测试类的初始化过程。

感谢每一个认真阅读我文章的人，礼尚往来总是要有的，虽然不是什么很值钱的东西，如果你用得到的话可以直接拿走：

这些资料，对于【软件测试】的朋友来说应该是最全面最完整的备战仓库，这个仓库也陪伴上万个测试工程师们走过最艰难的路程，希望也能帮助到你!有需要的小伙伴可以点击下方小卡片领取