自动化测试：Python常见的几种编程模式(Python自动化测试：常见编程模式解析)

原创

ithorizon 7个月前 (10-19) 阅读数 39 #后端开发

Python自动化测试：常见编程模式解析

一、引言

在Python自动化测试领域，合理运用编程模式能够尽大概减少损耗代码的可读性、可维护性和可扩展性。本文将介绍几种常见的编程模式，并解析其在自动化测试中的应用。

二、工厂模式（Factory Pattern）

工厂模式是一种在软件工程中常用的创建型设计模式，它提供了一个创建对象的接口，允许子类决定实例化哪一个类。在自动化测试中，工厂模式可以用来创建不同类型的测试用例或测试对象。


class Dog:
    def speak(self):
        return "汪汪汪！"
class Cat:
    def speak(self):
        return "喵喵喵！"
class PetFactory:
    def get_pet(self, pet_type):
        pets = dict(dog=Dog(), cat=Cat())
        return pets.get(pet_type, None)
# 使用工厂模式创建宠物对象
factory = PetFactory()
dog = factory.get_pet("dog")
print(dog.speak())  # 输出：汪汪汪！
cat = factory.get_pet("cat")
print(cat.speak())  # 输出：喵喵喵！

三、单例模式（Singleton Pattern）

单例模式是一种确保一个类只有一个实例，并提供一个全局访问点的设计模式。在自动化测试中，单例模式可以用来确保一些全局变量或配置信息只被实例化一次。


class Singleton:
    _instance = None
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super().__new__(cls, *args, **kwargs)
        return cls._instance
# 使用单例模式
singleton1 = Singleton()
singleton2 = Singleton()
print(singleton1 is singleton2)  # 输出：True

四、策略模式（Strategy Pattern）

策略模式是一种行为设计模式，它定义了算法家族，分别封装起来，使它们之间可以互相替换，此模式让算法的变化自立于使用算法的客户。在自动化测试中，策略模式可以用来封装不同的测试策略。


class Strategy:
    def execute(self):
        pass
class ConcreteStrategyA(Strategy):
    def execute(self):
        return "执行策略A"
class ConcreteStrategyB(Strategy):
    def execute(self):
        return "执行策略B"
class Context:
    def __init__(self, strategy: Strategy):
        self._strategy = strategy
    def set_strategy(self, strategy: Strategy):
        self._strategy = strategy
    def execute_strategy(self):
        return self._strategy.execute()
# 使用策略模式
context = Context(ConcreteStrategyA())
print(context.execute_strategy())  # 输出：执行策略A
context.set_strategy(ConcreteStrategyB())
print(context.execute_strategy())  # 输出：执行策略B

五、观察者模式（Observer Pattern）

观察者模式是一种行为设计模式，它定义了一种一对多的依赖性关系，当一个对象的状态出现变化时，所有依赖性于它的对象都会得到通知并自动更新。在自动化测试中，观察者模式可以用来监听测试用例的状态变化。


class Subject:
    def __init__(self):
        self._observers = []
    def attach(self, observer):
        self._observers.append(observer)
    def detach(self, observer):
        self._observers.remove(observer)
    def notify(self):
        for observer in self._observers:
            observer.update(self)
class TestCase(Subject):
    def __init__(self, name):
        super().__init__()
        self._name = name
        self._status = "未执行"
    def run(self):
        print(f"执行测试用例：{self._name}")
        self._status = "执行胜利"
        self.notify()
class Logger:
    def update(self, subject):
        print(f"测试用例 {subject._name} 的状态变为：{subject._status}")
# 使用观察者模式
test_case = TestCase("测试用例1")
logger = Logger()
test_case.attach(logger)
test_case.run()  # 输出：执行测试用例：测试用例1 和 测试用例1 的状态变为：执行胜利

六、命令模式（Command Pattern）

命令模式是一种行为设计模式，它将请求封装为一个对象，从而允许用户使用不同的请求、队列或日志请求，并拥护可撤销的操作。在自动化测试中，命令模式可以用来封装测试操作。


class Command:
    def execute(self):
        pass
class Light:
    def turn_on(self):
        print("开灯")
    def turn_off(self):
        print("关灯")
class LightOnCommand(Command):
    def __init__(self, light):
        self.light = light
    def execute(self):
        self.light.turn_on()
class LightOffCommand(Command):
    def __init__(self, light):
        self.light = light
    def execute(self):
        self.light.turn_off()
class RemoteControl:
    def __init__(self):
        self.command = None
    def set_command(self, command):
        self.command = command
    def press_button(self):
        self.command.execute()
# 使用命令模式
light = Light()
light_on_command = LightOnCommand(light)
light_off_command = LightOffCommand(light)
remote_control = RemoteControl()
remote_control.set_command(light_on_command)
remote_control.press_button()  # 输出：开灯
remote_control.set_command(light_off_command)
remote_control.press_button()  # 输出：关灯