Python深拷贝在接口自动化里的用法

深拷贝（deep copy）常用于复制请求参数、配置对象或其他复杂数据结构，以确保每次发送请求时使用的是独立的数据副本，避免不同请求之间的数据互相影响。例如，当你需要多次调用同一个接口，但每次调用的参数略有不同的时候，深拷贝可以帮助你创建参数对象的新实例。

基础示例

import requests
import copy
# 假设有一个包含接口请求参数的字典
base_params = {
    'user_id': 123,
    'data': {
        'name': 'Alice',
        'address': {
            'street': '123 Main St'
        }
    }
}
# 在接口自动化测试中，我们可能需要对某些参数进行修改后发起请求
def send_request(modified_params):
    # 使用深拷贝来创建原始参数的一个完整副本
    params = copy.deepcopy(base_params)
    # 现在可以安全地修改副本而不影响原始参数
    params['user_id'] = modified_params['user_id']
    params['data']['name'] = modified_params.get('new_name', params['data']['name'])
    # 发送HTTP请求
    response = requests.post('http://api.example.com/endpoint', jsnotallow=params)
    # 处理响应并验证结果...
# 调用函数，传入要修改的参数
test_case_1_params = {'user_id': 456, 'new_name': 'Bob'}
send_request(test_case_1_params)
# 下一个测试案例，使用不同的参数
test_case_2_params = {'user_id': 789, 'new_name': 'Charlie'}
send_request(test_case_2_params)

在这个例子中，copy.deepcopy() 方法被用来创建 base_params 的深拷贝，这样每个测试用例都可以根据需要独立修改参数，并且不会干扰其他测试用例或后续的请求。这对于维护数据一致性以及避免由于数据共享导致的问题非常有用。

深拷贝处理列表、字典嵌套的数据结构

包含多个请求参数集合的列表，每个集合代表一次独立的接口调用：

import copy
import requests
# 假设我们有一系列需要以不同参数发送的请求
base_requests = [
    {
        'method': 'POST',
        'url': 'http://api.example.com/user',
        'data': {
            'user_id': 1,
            'name': 'Alice'
        }
    },
    {
        'method': 'POST',
        'url': 'http://api.example.com/user',
        'data': {
            'user_id': 2,
            'name': 'Bob'
        }
    }
]
def send_requests(modified_requests):
    # 对原始请求列表进行深拷贝
    requests_to_send = copy.deepcopy(base_requests)
    for request in requests_to_send:
        # 根据测试需求修改每个请求的参数
        request['data']['name'] = modified_requests[request['data']['user_id']]['new_name']
        # 发送HTTP请求
        response = requests.request(request['method'], request['url'], jsnotallow=request['data'])
        # 处理响应并验证结果...
# 定义要修改的用户名称
modified_user_names = {
    1: 'Charlie',
    2: 'Dave'
}
# 调用函数，传入要修改的参数
send_requests(modified_user_names)

在这个例子中，通过深拷贝base_requests列表，我们可以对每个请求中的数据进行独立修改，而不会影响到其他请求或后续的测试。这样就能确保在并发或批量执行接口测试时，每次请求使用的都是独立的数据副本。

深拷贝管理复杂的会话状态或全局配置

全局配置对象，包含了所有请求的通用头信息或其他默认设置：

import requests
import copy
# 全局配置对象
global_config = {
    'headers': {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer some_token'
    },
    'timeout': 30,
    'proxies': {...}
}
# 定义一个发送请求的函数，利用深拷贝来创建全局配置的副本
def send_request(url, data, custom_cnotallow={}):
    # 创建全局配置的深拷贝
    config = copy.deepcopy(global_config)
    # 更新或添加自定义配置
    config.update(custom_config)
    # 发送HTTP请求
    response = requests.post(url, jsnotallow=data, **config)
    # 处理响应并验证结果...
# 使用默认配置发送请求
send_request('http://api.example.com/user', {'user_id': 1})
# 发送具有部分自定义配置的请求（如：更新令牌）
custom_config = {'headers': {'Authorization': 'Bearer new_token'}}
send_request('http://api.example.com/user', {'user_id': 2}, custom_config)

在这个例子中，通过深拷贝 global_config，我们可以在不改变原始全局配置的前提下，为每个单独的请求定制不同的配置项。这样在处理多用户、多环境或者需要临时修改某些配置参数的情况时，可以确保每次请求都基于独立且完整的配置对象，从而避免数据污染和错误发生。

深拷贝在持续集成（CI）或持续部署（CD）的场景使用

在并行执行多个接口测试用例时，每个测试任务可能会加载一套共享的基础数据，但需要独立操作这些数据以模拟不同的业务场景：

import threading
import copy
import requests
# 基础数据集
base_data = {
    'users': [
        {'id': 1, 'name': 'Alice'},
        {'id': 2, 'name': 'Bob'}
    ],
    'products': [...]
}
def run_test_case(test_case, copied_data):
    # 在线程内部对复制的数据进行修改和使用
    for user in copied_data['users']:
        if user['id'] == test_case['user_id']:
            user['name'] = test_case.get('new_name', user['name'])
    # 根据测试用例发送请求
    response = requests.put(f'http://api.example.com/user/{test_case["user_id"]}', jsnotallow=user)
    # 处理响应并验证结果...
# 定义测试用例列表
test_cases = [
    {'user_id': 1, 'new_name': 'Charlie'},
    {'user_id': 2, 'new_name': 'Dave'}
]
# 使用多线程并发执行测试用例，并为每个线程提供基础数据的深拷贝
threads = []
for case in test_cases:
    copied_data = copy.deepcopy(base_data)
    thread = threading.Thread(target=run_test_case, args=(case, copied_data))
    threads.append(thread)
    thread.start()
# 等待所有线程完成
for thread in threads:
    thread.join()

在这个例子中，通过在每个线程内部创建 base_data 的深拷贝，我们可以确保即使在并发环境下，不同测试用例之间也能安全地独立操作数据，避免了竞态条件和其他同步问题的发生。

深拷贝处理数据库或缓存中的数据

在执行测试用例前，你可能需要从数据库加载一些初始数据，然后基于这些数据进行修改和操作：

import copy
import db_connection  # 假设这是一个连接到数据库的模块
# 从数据库获取基础数据
base_data = db_connection.fetch_test_data()
def run_test_case(test_case, copied_data):
    # 在测试用例内部对复制的数据进行修改
    for record in copied_data['records']:
        if record['id'] == test_case['record_id']:
            record['status'] = test_case['new_status']
    # 执行更新数据库的操作（这里仅为示例，实际应使用db_connection模块）
    updated_data = update_database(copied_data)
    # 根据新状态发送请求并验证响应结果
    response = requests.get(f'http://api.example.com/record/{test_case["record_id"]}')
    assert response.json()['status'] == test_case['new_status']
# 定义测试用例列表
test_cases = [
    {'record_id': 1, 'new_status': 'active'},
    {'record_id': 2, 'new_status': 'inactive'}
]
# 对每个测试用例运行，并提供数据库数据的深拷贝
for case in test_cases:
    copied_data = copy.deepcopy(base_data)
    run_test_case(case, copied_data)
# 清理资源，如重置数据库状态至原始值
db_connection.reset_to_original_data(base_data)

在这个例子中，通过深拷贝从数据库获取的基础数据，我们可以安全地模拟各种业务场景下的数据更新操作，同时保证不会影响到其他测试用例或后续的数据恢复过程。在测试结束后，可以将数据库状态重置为初始状态，以确保测试环境的一致性。