# Python单元测试示例
import unittest

class Calculator:
def add(self, a, b):
return a + b

def subtract(self, a, b):
return a – b

def multiply(self, a, b):
return a * b

def divide(self, a, b):
if b == 0:
raise ValueError(“Cannot divide by zero”)
return a / b

class TestCalculator(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()

def test_add(self):
self.assertEqual(self.calculator.add(2, 3), 5)
self.assertEqual(self.calculator.add(-1, 1), 0)
self.assertEqual(self.calculator.add(0, 0), 0)

def test_subtract(self):
self.assertEqual(self.calculator.subtract(5, 3), 2)
self.assertEqual(self.calculator.subtract(0, 5), -5)
self.assertEqual(self.calculator.subtract(-1, -1), 0)

def test_multiply(self):
self.assertEqual(self.calculator.multiply(2, 3), 6)
self.assertEqual(self.calculator.multiply(-1, 1), -1)
self.assertEqual(self.calculator.multiply(0, 5), 0)

def test_divide(self):
self.assertEqual(self.calculator.divide(6, 3), 2)
self.assertEqual(self.calculator.divide(5, 2), 2.5)
with self.assertRaises(ValueError):
self.calculator.divide(5, 0)

if __name__ == ‘__main__’:
unittest.main()

# 运行单元测试
$ python test_calculator.py

# 输出案例
..
———————————————————————-
Ran 4 tests in 0.001s

OK

# Python集成测试示例
import unittest
from calculator import Calculator
from database import Database

class TestCalculatorIntegration(unittest.TestCase):
def setUp(self):
self.calculator = Calculator()
self.database = Database()

def test_calculator_with_database(self):
# 计算结果
result = self.calculator.add(2, 3)
# 保存结果到数据库
self.database.save_result(“add”, 2, 3, result)
# 从数据库获取结果
saved_result = self.database.get_result(“add”, 2, 3)
# 验证结果
self.assertEqual(saved_result, result)

if __name__ == ‘__main__’:
unittest.main()

# 运行集成测试
$ python test_integration.py

# 输出案例
.
———————————————————————-
Ran 1 test in 0.010s

OK

# Python API测试示例
import unittest
import requests

class TestAPIs(unittest.TestCase):
def setUp(self):
self.base_url = “http://fgedudb:5000/api”

def test_get_users(self):
response = requests.get(f”{self.base_url}/users”)
self.assertEqual(response.status_code, 200)
self.assertIsInstance(response.json(), list)

def test_create_user(self):
user_data = {
“name”: “Test User”,
“email”: “test@fgedu.net.cn”
}
response = requests.post(f”{self.base_url}/users”, json=user_data)
self.assertEqual(response.status_code, 201)
self.assertEqual(response.json()[“name”], user_data[“name”])
self.assertEqual(response.json()[“email”], user_data[“email”])

def test_get_user(self):
# 先创建用户
user_data = {
“name”: “Test User”,
“email”: “test@fgedu.net.cn”
}
create_response = requests.post(f”{self.base_url}/users”, json=user_data)
user_id = create_response.json()[“id”]

# 获取用户
response = requests.get(f”{self.base_url}/users/{user_id}”)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()[“id”], user_id)
self.assertEqual(response.json()[“name”], user_data[“name”])

def test_update_user(self):
# 先创建用户
user_data = {
“name”: “Test User”,
“email”: “test@fgedu.net.cn”
}
create_response = requests.post(f”{self.base_url}/users”, json=user_data)
user_id = create_response.json()[“id”]

# 更新用户
update_data = {
“name”: “Updated User”,
“email”: “updated@fgedu.net.cn”
}
response = requests.put(f”{self.base_url}/users/{user_id}”, json=update_data)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.json()[“name”], update_data[“name”])
self.assertEqual(response.json()[“email”], update_data[“email”])

def test_delete_user(self):
# 先创建用户
user_data = {
“name”: “Test User”,
“email”: “test@fgedu.net.cn”
}
create_response = requests.post(f”{self.base_url}/users”, json=user_data)
user_id = create_response.json()[“id”]

# 删除用户
response = requests.delete(f”{self.base_url}/users/{user_id}”)
self.assertEqual(response.status_code, 204)

# 验证用户已删除
get_response = requests.get(f”{self.base_url}/users/{user_id}”)
self.assertEqual(get_response.status_code, 404)

if __name__ == ‘__main__’:
unittest.main()

# 运行API测试
$ python test_api.py

# 输出案例
…..
———————————————————————-
Ran 5 tests in 0.100s

OK

# Python UI测试示例（使用Selenium）
import unittest
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
import time

class TestUITests(unittest.TestCase):
def setUp(self):
self.driver = webdriver.Chrome()
self.driver.get(“http://fgedudb:8080”)

def test_login(self):
# 点击登录按钮
login_button = self.driver.find_element(By.ID, “login-button”)
login_button.click()

# 输入fgedu和密码
username_input = self.driver.find_element(By.ID, “username”)
password_input = self.driver.find_element(By.ID, “password”)

username_input.send_keys(“testuser”)
password_input.send_keys(“password123”)

# 提交表单
submit_button = self.driver.find_element(By.ID, “submit-button”)
submit_button.click()

# 验证登录成功
time.sleep(1) # 等待页面加载
welcome_message = self.driver.find_element(By.ID, “welcome-message”)
self.assertIn(“Welcome, testuser”, welcome_message.text)

def test_register(self):
# 点击注册按钮
register_button = self.driver.find_element(By.ID, “register-button”)
register_button.click()

# 输入注册信息
username_input = self.driver.find_element(By.ID, “username”)
email_input = self.driver.find_element(By.ID, “email”)
password_input = self.driver.find_element(By.ID, “password”)
confirm_password_input = self.driver.find_element(By.ID, “confirm-password”)

username_input.send_keys(“newuser”)
email_input.send_keys(“newuser@fgedu.net.cn”)
password_input.send_keys(“password123”)
confirm_password_input.send_keys(“password123”)

# 提交表单
submit_button = self.driver.find_element(By.ID, “submit-button”)
submit_button.click()

# 验证注册成功
time.sleep(1) # 等待页面加载
success_message = self.driver.find_element(By.ID, “success-message”)
self.assertIn(“Registration successful”, success_message.text)

def tearDown(self):
self.driver.quit()

if __name__ == ‘__main__’:
unittest.main()

# 运行UI测试
$ python test_ui.py

# 输出案例
..
———————————————————————-
Ran 2 tests in 10.000s

OK

# JMeter性能测试示例
# 创建测试计划
# 1. 添加线程组
# 2. 添加HTTP请求
# 3. 添加监听器
# 4. 运行测试

# JMeter命令行运行
$ jmeter -n -t test-plan.jmx -l results.jtl -e -o results

# Gatling性能测试示例
import io.gatling.core.Predef._
import io.gatling.http.Predef._
import scala.concurrent.duration._

class LoadTest extends Simulation {
val httpProtocol = http
.baseUrl(“http://fgedudb:8080”)
.acceptHeader(“text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8”)
.doNotTrackHeader(“1”)
.acceptLanguageHeader(“en-US,en;q=0.5”)
.acceptEncodingHeader(“gzip, deflate”)
.userAgentHeader(“Mozilla/5.0 (Windows NT 5.1; rv:31.0) Gecko/20100101 Firefox/31.0”)

val scn = scenario(“Load Test”)
.exec(http(“request_1”)
.get(“/api/users”))
.pause(5)

setUp(
scn.inject(rampUsers(100) during (10 seconds))
).protocols(httpProtocol)
}

# 运行Gatling测试
$ gatling.sh -s LoadTest

# 输出案例
================================================================================
—- Global Information ———————————————————
> request count 1000 (OK=1000 KO=0 )
> min response time 50 (OK=50 KO=- )
> max response time 200 (OK=200 KO=- )
> mean response time 100 (OK=100 KO=- )
> std deviation 25 (OK=25 KO=- )
> response time 50th percentile 95 (OK=95 KO=- )
> response time 75th percentile 110 (OK=110 KO=- )
> response time 95th percentile 150 (OK=150 KO=- )
> response time 99th percentile 180 (OK=180 KO=- )
> mean requests/sec 10 (OK=10 KO=- )
—- Response Time Distribution ————————————————
> t < 800 ms 1000 (100%) > 800 ms < t < 1200 ms 0 ( 0%) > t > 1200 ms 0 ( 0%)
> failed 0 ( 0%)
================================================================================

风哥风哥提示：不同类型的自动化测试适用于不同的场景，选择合适的测试类型可以提高测试效率和质量。

3. 自动化测试工具

3.1 单元测试工具

• Python：unittest, pytest, nose2
• Java：JUnit, TestNG
• JavaScript：Jest, Mocha, Jasmine
• C#：NUnit, MSTest
• Go：testing package

3.2 API测试工具

• Postman：功能强大的API测试工具
• REST-assured：Java的REST API测试库
• PyTest-HTTP：Python的HTTP测试库
• SoapUI：SOAP和REST API测试工具
• Karate：API测试框架

3.3 UI测试工具

• Selenium：广泛使用的Web UI测试工具
• Cypress：现代化的前端测试工具
• Playwright：Microsoft的端到端测试工具
• Appium：移动应用测试工具
• TestComplete：综合测试工具

3.4 性能测试工具

• JMeter：Apache的性能测试工具
• Gatling：基于Scala的性能测试工具
• LoadRunner：商业性能测试工具
• Locust：Python的性能测试工具
• K6：基于JavaScript的性能测试工具

3.5 测试管理工具

• JIRA：项目管理和缺陷跟踪工具
• TestRail：测试用例管理工具
• Zephyr：JIRA的测试管理插件
• qTest：测试管理平台
• TestLink：开源测试管理工具

学习交流加群风哥微信: itpux-com

4. 自动化测试框架

4.1 测试框架设计

# 测试框架结构
# 1. 测试用例层：包含具体的测试用例
# 2. 页面对象层：封装页面元素和操作
# 3. 工具层：提供通用的工具函数
# 4. 配置层：管理测试配置

# 页面对象模式示例
class LoginPage:
def __init__(self, driver):
self.driver = driver
self.username_input = (By.ID, “username”)
self.password_input = (By.ID, “password”)
self.submit_button = (By.ID, “submit-button”)

def enter_username(self, username):
self.driver.find_element(*self.username_input).send_keys(username)

def enter_password(self, password):
self.driver.find_element(*self.password_input).send_keys(password)

def click_submit(self):
self.driver.find_element(*self.submit_button).click()

class HomePage:
def __init__(self, driver):
self.driver = driver
self.welcome_message = (By.ID, “welcome-message”)

def get_welcome_message(self):
return self.driver.find_element(*self.welcome_message).text

# 测试用例使用页面对象
class TestLogin(unittest.TestCase):
def setUp(self):
self.driver = webdriver.Chrome()
self.driver.get(“http://fgedudb:8080”)
self.login_page = LoginPage(self.driver)
self.home_page = HomePage(self.driver)

def test_login(self):
self.login_page.enter_username(“testuser”)
self.login_page.enter_password(“password123”)
self.login_page.click_submit()
time.sleep(1)
self.assertIn(“Welcome, testuser”, self.home_page.get_welcome_message())

def tearDown(self):
self.driver.quit()

# 测试数据管理
# 1. 硬编码测试数据
# 2. 外部配置文件
# 3. 数据库
# 4. 数据生成器

# 使用外部配置文件
import configparser

config = configparser.ConfigParser()
config.read(‘config.ini’)

username = config[‘Login’][‘username’]
password = config[‘Login’][‘password’]

# 使用JSON文件
import json

with open(‘test_data.json’, ‘r’) as f:
test_data = json.load(f)

username = test_data[‘login’][‘username’]
password = test_data[‘login’][‘password’]

# 使用数据生成器
import faker

fake = faker.Faker()

username = fake.user_name()
email = fake.email()
password = fake.password()

# 测试数据示例
{
“login”: {
“valid”: {
“username”: “testuser”,
“password”: “password123”
},
“invalid”: {
“username”: “invaliduser”,
“password”: “wrongpassword”
}
},
“registration”: {
“valid”: {
“username”: “newuser”,
“email”: “newuser@fgedu.net.cn”,
“password”: “password123”,
“confirm_password”: “password123”
},
“invalid”: {
“username”: “”,
“email”: “invalidemail”,
“password”: “short”,
“confirm_password”: “different”
}
}
}

# 测试报告生成
# 使用pytest-html生成HTML报告
$ pip install pytest pytest-html
$ pytest –html=report.html

# 使用Allure生成测试报告
$ pip install allure-pytest
$ pytest –alluredir=allure-results
$ allure serve allure-results

# 使用JUnit XML格式报告
$ pytest –junitxml=results.xml

# 集成到CI/CD
# Jenkins配置
# 1. 安装JUnit插件
# 2. 配置构建步骤运行测试
# 3. 配置测试报告收集

# GitHub Actions配置
name: CI

on: [push, pull_request]

jobs:
test:
runs-on: ubuntu-latest
steps:
– uses: actions/checkout@v2
– name: Set up Python
uses: actions/setup-python@v2
with:
python-version: ‘3.8’
– name: Install dependencies
run: |
python -m pip install –upgrade pip
pip install pytest pytest-html
– name: Run tests
run: pytest –html=report.html
– name: Upload test report
uses: actions/upload-artifact@v2
with:
name: test-report
path: report.html

学习交流加群风哥QQ113257174

5. 自动化测试实施

5.1 测试计划

# 自动化测试计划
1. 确定测试范围：哪些功能需要自动化测试
2. 选择测试工具：根据测试类型选择合适的工具
3. 设计测试框架：建立测试框架结构
4. 编写测试用例：编写具体的测试用例
5. 执行测试：运行测试并分析结果
6. 维护测试：更新和维护测试用例

# 测试计划示例
## 测试范围
– 核心功能：登录、注册、用户管理
– API接口：用户API、产品API、订单API
– 性能测试：登录接口、产品列表接口

## 测试工具
– 单元测试：pytest
– API测试：requests
– UI测试：Selenium
– 性能测试：JMeter

## 测试框架
– 页面对象模式：封装页面元素和操作
– 数据驱动：使用外部数据文件
– 测试报告：使用pytest-html和Allure

## 测试用例
– 登录功能：正常登录、异常登录
– 注册功能：正常注册、异常注册
– 用户管理：创建用户、更新用户、删除用户
– 产品管理：创建产品、查询产品、更新产品
– 订单管理：创建订单、查询订单、支付订单

## 执行计划
– 每日执行：回归测试
– 每周执行：完整测试
– 发布前执行：预发布测试

# 测试环境配置
# 使用Docker配置测试环境
$ docker-compose up -d

# docker-compose.yml示例
version: ‘3’
services:
web:
build: .
ports:
– “8080:8080”
depends_on:
– db
db:
image: mysql:5.7
environment:
MYSQL_ROOT_PASSWORD: root
MYSQL_DATABASE: testdb
ports:
– “3306:3306”
selenium:
image: selenium/standalone-chrome
ports:
– “4444:4444”

# 使用Vagrant配置测试环境
$ vagrant up

# Vagrantfile示例
Vagrant.configure(“2”) do |config|
config.vm.box = “ubuntu/focal64”
config.vm.network “forwarded_port”, guest: 8080, host: 8080
config.vm.network “forwarded_port”, guest: 3306, host: 3306
config.vm.provision “shell”, inline: <<-SHELL apt-get update apt-get install -y python3 python3-pip mysql-server pip3 install flask mysql-connector-python # 启动应用 cd /vagrant python3 app.py & SHELL end # 配置测试环境变量 # .env文件 TEST_ENV=staging TEST_URL=http://fgedudb:8080 DB_HOST=fgedudb DB_PORT=3306 DB_NAME=testdb DB_USER=root DB_PASSWORD=root # 加载环境变量 import os from dotenv import load_dotenv load_dotenv() TEST_URL = os.getenv('TEST_URL') DB_HOST = os.getenv('DB_HOST')

# 测试执行
# 运行单元测试
$ python -m unittest discover

# 运行pytest测试
$ pytest

# 运行特定测试文件
$ pytest test_login.py

# 运行特定测试方法
$ pytest test_login.py::TestLogin::test_valid_login

# 运行测试并生成报告
$ pytest –html=report.html

# 运行测试并生成JUnit XML报告
$ pytest –junitxml=results.xml

# 运行Selenium测试
$ python test_ui.py

# 运行JMeter测试
$ jmeter -n -t test-plan.jmx -l results.jtl -e -o results

# 运行Gatling测试
$ gatling.sh -s LoadTest

# 并行运行测试
$ pytest -n auto

# 失败时停止测试
$ pytest -x

# 运行标记的测试
$ pytest -m smoke

# 测试标记示例
import pytest

@pytest.mark.smoke
def test_login():
pass

@pytest.mark.regression
def test_user_management():
pass

更多学习教程公众号风哥教程itpux_com

6. 持续集成与自动化测试

6.1 CI/CD配置

# Jenkins配置
# 1. 安装Jenkins
# 2. 安装插件：JUnit, HTML Publisher, Allure
# 3. 创建构建任务
# 4. 配置构建步骤
# 5. 配置测试报告

# Jenkinsfile示例
pipeline {
agent any
stages {
stage(‘Checkout’) {
steps {
checkout scm
}
}
stage(‘Install Dependencies’) {
steps {
sh ‘pip install -r requirements.txt’
}
}
stage(‘Run Tests’) {
steps {
sh ‘pytest –html=report.html –junitxml=results.xml’
}
}
stage(‘Publish Report’) {
steps {
publishHTML([
allowMissing: false,
alwaysLinkToLastBuild: true,
keepAll: true,
reportDir: ‘.’,
reportFiles: ‘report.html’,
reportName: ‘Test Report’
])
junit ‘results.xml’
}
}
}
}

# GitHub Actions配置
name: CI

on: [push, pull_request]

jobs:
test:
runs-on: ubuntu-latest
steps:
– uses: actions/checkout@v2
– name: Set up Python
uses: actions/setup-python@v2
with:
python-version: ‘3.8’
– name: Install dependencies
run: |
python -m pip install –upgrade pip
pip install -r requirements.txt
pip install pytest pytest-html
– name: Run tests
run: pytest –html=report.html –junitxml=results.xml
– name: Upload test report
uses: actions/upload-artifact@v2
with:
name: test-report
path: report.html
– name: Upload test results
uses: actions/upload-artifact@v2
with:
name: test-results
path: results.xml

# GitLab CI配置
# .gitlab-ci.yml
image: python:3.8

stages:
– test

run_tests:
stage: test
script:
– pip install -r requirements.txt
– pip install pytest pytest-html
– pytest –html=report.html –junitxml=results.xml
artifacts:
paths:
– report.html
– results.xml
expire_in: 1 week

# 集成测试到CI/CD
# 1. 单元测试：每次提交时运行
# 2. 集成测试：每日运行
# 3. 性能测试：每周运行
# 4. 回归测试：发布前运行

# 测试覆盖率
# 安装测试覆盖率工具
$ pip install pytest-cov

# 运行测试并生成覆盖率报告
$ pytest –cov=myapp –cov-report=html

# 查看覆盖率报告
# 打开 htmlcov/index.html

# 代码质量检查
# 安装代码质量工具
$ pip install flake8

# 运行代码质量检查
$ flake8 myapp

# 安全扫描
# 安装安全扫描工具
$ pip install safety bandit

# 运行安全扫描
$ safety check
$ bandit -r myapp

# 静态代码分析
# 安装静态代码分析工具
$ pip install pylint

# 运行静态代码分析
$ pylint myapp

# 持续测试策略
1. 提交触发测试：每次代码提交时运行单元测试
2. 定时测试：每天运行集成测试和回归测试
3. 部署前测试：部署前运行完整测试套件
4. 生产监控：监控生产环境的性能和可用性

# 测试自动化流程
1. 代码提交：开发人员提交代码
2. 构建：CI系统构建代码
3. 测试：运行自动化测试
4. 部署：部署到测试环境
5. 验证：验证部署是否成功
6. 发布：部署到生产环境

# 测试监控
# 安装监控工具
$ pip install prometheus-client

# 配置测试监控
from prometheus_client import Counter, Histogram, start_http_server

# 定义指标
test_runs = Counter(‘test_runs’, ‘Number of test runs’)
test_failures = Counter(‘test_failures’, ‘Number of test failures’)
test_duration = Histogram(‘test_duration’, ‘Test duration in seconds’)

# 启动监控服务器
start_http_server(8000)

# 在测试中使用
@test_duration.time()
def test_function():
test_runs.inc()
try:
# 测试代码
pass
except Exception:
test_failures.inc()
raise

author:www.itpux.com

7. 最佳实践

7.1 自动化测试最佳实践

• 选择合适的测试工具：根据测试类型选择合适的工具
• 设计良好的测试框架：使用页面对象模式、数据驱动等
• 编写可维护的测试用例：使用清晰的命名和结构
• 优先测试核心功能：确保核心功能的质量
• 定期运行测试：集成到CI/CD流程中
• 监控测试结果：及时发现和解决问题
• 维护测试数据：确保测试数据的一致性和可靠性
• 持续改进测试：根据反馈优化测试用例
• 培训团队成员：提高团队的测试技能
• 文档化测试流程：便于团队成员理解和遵循

7.2 测试用例设计

# 测试用例设计原则
1. 独立性：每个测试用例应该独立运行，不依赖于其他测试用例
2. 可重复性：测试用例应该可以重复运行，结果一致
3. 明确性：测试用例的目的和步骤应该清晰明确
4. 全面性：测试用例应该覆盖各种场景和边界条件
5. 可维护性：测试用例应该易于维护和更新

# 测试用例模板
## 测试用例ID: TC-001
## 测试用例名称: 登录功能测试
## 测试目的: 验证用户可以使用正确的fgedu和密码登录
## 测试环境: 测试环境
## 测试步骤:
1. 打开登录页面
2. 输入fgedu: testuser
3. 输入密码: password123
4. 点击登录按钮
## 预期结果: 登录成功，跳转到首页，显示欢迎消息
## 实际结果:
## 测试状态:

# 边界条件测试
# 1. 空值测试
# 2. 最大值测试
# 3. 最小值测试
# 4. 特殊字符测试
# 5. 负数测试
# 6. 零值测试

# 等价类划分
# 有效等价类：
# – 正确的fgedu和密码
# 无效等价类：
# – 空fgedu
# – 空密码
# – 错误的fgedu
# – 错误的密码

# 因果图法
# 原因：
# – C1: fgedu正确
# – C2: 密码正确
# 结果：
# – E1: 登录成功
# – E2: 登录失败
# 规则：
# – C1 AND C2 → E1
# – NOT (C1 AND C2) → E2

# 测试维护策略
1. 定期更新测试用例：随着功能变更更新测试用例
2. 清理过时的测试用例：删除不再需要的测试用例
3. 优化测试执行时间：减少测试执行时间
4. 修复失败的测试用例：及时修复失败的测试用例
5. 备份测试数据：确保测试数据的安全性
6. 版本控制测试代码：使用Git等版本控制工具
7. 文档化测试变更：记录测试的变更和原因
8. 定期审查测试覆盖率：确保测试覆盖所有关键功能

# 测试维护工具
# 1. 测试管理工具：TestRail, JIRA
# 2. 版本控制工具：Git, SVN
# 3. 持续集成工具：Jenkins, GitHub Actions
# 4. 测试报告工具：Allure, pytest-html

# 测试自动化维护流程
1. 监控测试结果：定期查看测试结果
2. 分析失败原因：分析测试失败的原因
3. 修复测试用例：修复失败的测试用例
4. 更新测试数据：更新测试数据以适应功能变更
5. 优化测试执行：优化测试执行时间和资源使用
6. 文档化变更：记录测试的变更和原因
7. 培训团队：培训团队成员了解测试变更