# 使用Jest进行JavaScript单元测试
$ npm install –save-dev jest

# 创建测试文件
$ cat sum.test.js
const sum = require(‘./sum’);

test(‘adds 1 + 2 to equal 3’, () => {
expect(sum(1, 2)).toBe(3);
});

test(‘adds 0 + 0 to equal 0’, () => {
expect(sum(0, 0)).toBe(0);
});

test(‘adds negative numbers’, () => {
expect(sum(-1, -2)).toBe(-3);
});

# 创建被测试文件
$ cat sum.js
function sum(a, b) {
return a + b;
}

module.exports = sum;

# 运行测试
$ npx jest

# 查看测试结果
PASS ./sum.test.js
✓ adds 1 + 2 to equal 3 (5ms)
✓ adds 0 + 0 to equal 0 (1ms)
✓ adds negative numbers (1ms)

Test Suites: 1 passed, 1 total
Tests: 3 passed, 3 total
Time: 1.023s
Ran all test suites.

# 使用Mocha和Chai进行集成测试
$ npm install –save-dev mocha chai supertest

# 创建测试文件
$ cat api.test.js
const request = require(‘supertest’);
const app = require(‘./app’);
const expect = require(‘chai’).expect;

describe(‘API Tests’, () => {
it(‘should return 200 for GET /api/users’, (done) => {
request(app)
.get(‘/api/users’)
.expect(200)
.end((err, res) => {
if (err) return done(err);
expect(res.body).to.be.an(‘array’);
done();
});
});

it(‘should create a new user’, (done) => {
request(app)
.post(‘/api/users’)
.send({ name: ‘Test User’, email: ‘test@fgedu.net.cn’ })
.expect(201)
.end((err, res) => {
if (err) return done(err);
expect(res.body).to.have.property(‘id’);
expect(res.body.name).to.equal(‘Test User’);
done();
});
});
});

# 创建应用文件
$ cat app.js
const express = require(‘express’);
const app = express();

app.use(express.json());

let users = [
{ id: 1, name: ‘User 1’, email: ‘user1@fgedu.net.cn’ },
{ id: 2, name: ‘User 2’, email: ‘user2@fgedu.net.cn’ }
];

app.get(‘/api/users’, (req, res) => {
res.json(users);
});

app.post(‘/api/users’, (req, res) => {
const newUser = {
id: users.length + 1,
name: req.body.name,
email: req.body.email
};
users.push(newUser);
res.status(201).json(newUser);
});

module.exports = app;

# 运行测试
$ npx mocha api.test.js

# 查看测试结果
API Tests
✓ should return 200 for GET /api/users
✓ should create a new user

2 passing (50ms)

风哥风哥提示：单元测试和集成测试是自动化测试的基础，它们分别测试代码的各个部分和组件之间的交互。

3. 自动化测试工具

3.1 Selenium

# 安装Selenium WebDriver
$ npm install –save-dev selenium-webdriver

# 创建测试文件
$ cat selenium.test.js
const { Builder, By, Key, until } = require(‘selenium-webdriver’);

async function testGoogleSearch() {
let driver = await new Builder().forBrowser(‘chrome’).build();
try {
// 打开Google
await driver.get(‘https://www.google.com’);

// 查找搜索框并输入内容
let searchBox = await driver.findElement(By.name(‘q’));
await searchBox.sendKeys(‘Selenium WebDriver’, Key.RETURN);

// 等待搜索结果
await driver.wait(until.titleContains(‘Selenium WebDriver’), 10000);

// 获取搜索结果数量
let results = await driver.findElements(By.css(‘h3’));
console.log(`Found ${results.length} results`);

// 验证结果
let firstResult = await results[0].getText();
console.log(`First result: ${firstResult}`);
} finally {
// 关闭浏览器
await driver.quit();
}
}

testGoogleSearch();

# 运行测试
$ node selenium.test.js

# 查看测试结果
Found 10 results
First result: Selenium WebDriver

# 安装Cypress
$ npm install –save-dev cypress

# 打开Cypress
$ npx cypress open

# 创建测试文件
$ cat cypress/integration/google_search.spec.js
describe(‘Google Search’, () => {
it(‘should search for Selenium WebDriver’, () => {
// 打开Google
cy.visit(‘https://www.google.com’);

// 查找搜索框并输入内容
cy.get(‘input[name=”q”]’).type(‘Selenium WebDriver{enter}’);

// 等待搜索结果
cy.title().should(‘include’, ‘Selenium WebDriver’);

// 验证结果
cy.get(‘h3’).should(‘have.length.at.least’, 1);
cy.get(‘h3’).first().should(‘be.visible’);
});
});

# 运行测试
$ npx cypress run

# 查看测试结果
====================================================================================================
(Run Finished)
Spec Tests Passing Failing Pending Skipped
┌──────────────────────────────────────────────────────────────────────────────────────────────────┐
│ ✅ google_search.spec.js 1 1 0 – – │
└──────────────────────────────────────────────────────────────────────────────────────────────────┘
All specs passed! ✨

# 安装Playwright
$ npm install –save-dev playwright

# 创建测试文件
$ cat playwright.test.js
const { chromium } = require(‘playwright’);

async function testGoogleSearch() {
// 启动浏览器
const browser = await chromium.launch();
const page = await browser.newPage();

try {
// 打开Google
await page.goto(‘https://www.google.com’);

// 查找搜索框并输入内容
await page.fill(‘input[name=”q”]’, ‘Playwright’);
await page.press(‘input[name=”q”]’, ‘Enter’);

// 等待搜索结果
await page.waitForNavigation();

// 获取搜索结果数量
const results = await page.$$(‘h3’);
console.log(`Found ${results.length} results`);

// 验证结果
const firstResult = await page.textContent(‘h3’);
console.log(`First result: ${firstResult}`);
} finally {
// 关闭浏览器
await browser.close();
}
}

testGoogleSearch();

# 运行测试
$ node playwright.test.js

# 查看测试结果
Found 10 results
First result: Playwright

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

4. 测试框架

4.1 JUnit (Java)

# 创建测试类
$ cat CalculatorTest.java
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class CalculatorTest {

@Test
public void testAdd() {
Calculator calculator = new Calculator();
assertEquals(5, calculator.add(2, 3));
assertEquals(0, calculator.add(0, 0));
assertEquals(-1, calculator.add(-2, 1));
}

@Test
public void testSubtract() {
Calculator calculator = new Calculator();
assertEquals(1, calculator.subtract(3, 2));
assertEquals(0, calculator.subtract(5, 5));
assertEquals(-3, calculator.subtract(2, 5));
}
}

# 创建被测试类
$ cat Calculator.java
public class Calculator {
public int add(int a, int b) {
return a + b;
}

public int subtract(int a, int b) {
return a – b;
}
}

# 编译并运行测试
$ javac -cp junit-jupiter-api-5.8.2.jar:junit-jupiter-engine-5.8.2.jar:apiguardian-api-1.1.2.jar Calculator.java CalculatorTest.java
$ java -cp .:junit-jupiter-api-5.8.2.jar:junit-jupiter-engine-5.8.2.jar:apiguardian-api-1.1.2.jar:junit-platform-console-standalone-1.8.2.jar org.junit.runner.JUnitCore CalculatorTest

# 查看测试结果
JUnit version 4.13.2
..
Time: 0.02

OK (2 tests)

# 安装PyTest
$ pip install pytest

# 创建测试文件
$ cat test_calculator.py
def test_add():
from calculator import add
assert add(2, 3) == 5
assert add(0, 0) == 0
assert add(-2, 1) == -1

def test_subtract():
from calculator import subtract
assert subtract(3, 2) == 1
assert subtract(5, 5) == 0
assert subtract(2, 5) == -3

# 创建被测试文件
$ cat calculator.py
def add(a, b):
return a + b

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

# 运行测试
$ pytest test_calculator.py -v

# 查看测试结果
============================= test session starts ==============================
platform linux — Python 3.8.10, pytest-7.1.2, pluggy-1.0.0
rootdir: /home/user
collected 2 items

test_calculator.py::test_add PASSED
test_calculator.py::test_subtract PASSED

============================== 2 passed in 0.02s ===============================

# 创建测试类
$ cat CalculatorTest.java
import org.testng.annotations.Test;
import static org.testng.Assert.assertEquals;

public class CalculatorTest {

@Test
public void testAdd() {
Calculator calculator = new Calculator();
assertEquals(calculator.add(2, 3), 5);
assertEquals(calculator.add(0, 0), 0);
assertEquals(calculator.add(-2, 1), -1);
}

@Test
public void testSubtract() {
Calculator calculator = new Calculator();
assertEquals(calculator.subtract(3, 2), 1);
assertEquals(calculator.subtract(5, 5), 0);
assertEquals(calculator.subtract(2, 5), -3);
}
}

# 编译并运行测试
$ javac -cp testng-7.5.jar Calculator.java CalculatorTest.java
$ java -cp .:testng-7.5.jar:jcommander-1.82.jar:guice-4.0.jar:bsh-2.0b4.jar org.testng.TestNG CalculatorTest.java

# 查看测试结果
[TestNG] Running: CalculatorTest.java

=============================================== CalculatorTest
Tests run: 2, Failures: 0, Skips: 0
===============================================

学习交流加群风哥QQ113257174

5. CI/CD集成

5.1 Jenkins集成

# 创建Jenkinsfile
$ cat Jenkinsfile
pipeline {
agent any
stages {
stage(‘Checkout’) {
steps {
git branch: ‘master’, url: ‘https://github.com/fgedu/myapp.git’
}
}
stage(‘Build’) {
steps {
sh ‘npm install’
sh ‘npm run build’
}
}
stage(‘Test’) {
steps {
sh ‘npm test’
}
}
stage(‘Deploy’) {
steps {
sh ‘npm run deploy’
}
}
}
post {
success {
echo ‘Build successful!’
}
failure {
echo ‘Build failed!’
}
}
}

# 配置Jenkins
# 1. 安装Jenkins
# 2. 安装Node.js插件
# 3. 创建新的Pipeline任务
# 4. 配置Pipeline脚本从Git仓库获取
# 5. 保存并构建

# 查看构建结果
# 访问Jenkins控制台 -> 任务 -> 构建历史

# 创建GitHub Actions配置文件
$ cat .github/workflows/test.yml
name: Test

on:
push:
branches: [ master ]
pull_request:
branches: [ master ]

jobs:
test:
runs-on: ubuntu-latest
steps:
– uses: actions/checkout@v2
– name: Set up Node.js
uses: actions/setup-node@v2
with:
node-version: ’14’
– name: Install dependencies
run: npm install
– name: Run tests
run: npm test

# 提交代码到GitHub
$ git add .github/workflows/test.yml
$ git commit -m “Add GitHub Actions workflow”
$ git push

# 查看测试结果
# 访问GitHub仓库 -> Actions标签

# 创建.gitlab-ci.yml文件
$ cat .gitlab-ci.yml
stages:
– build
– test
– deploy

build:
stage: build
script:
– npm install
– npm run build
artifacts:
paths:
– build/

test:
stage: test
script:
– npm test

deploy:
stage: deploy
script:
– npm run deploy
only:
– master

# 提交代码到GitLab
$ git add .gitlab-ci.yml
$ git commit -m “Add GitLab CI/CD configuration”
$ git push

# 查看测试结果
# 访问GitLab仓库 -> CI/CD标签

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

6. 最佳实践

6.1 测试策略

• 制定明确的测试目标和范围
• 选择合适的测试工具和框架
• 建立测试用例管理系统
• 优先测试核心功能
• 定期更新测试用例

6.2 测试用例设计

# 测试用例设计示例
$ cat test-cases.md
# 登录功能测试用例

## 测试用例1: 正常登录
– 测试步骤：
1. 打开登录页面
2. 输入正确的fgedu和密码
3. 点击登录按钮
– 预期结果：
– 登录成功
– 跳转到首页
– 显示用户信息

## 测试用例2: 错误密码
– 测试步骤：
1. 打开登录页面
2. 输入正确的fgedu和错误的密码
3. 点击登录按钮
– 预期结果：
– 登录失败
– 显示错误提示信息

## 测试用例3: 空fgedu
– 测试步骤：
1. 打开登录页面
2. 输入空fgedu和正确的密码
3. 点击登录按钮
– 预期结果：
– 显示fgedu不能为空的提示

## 测试用例4: 空密码
– 测试步骤：
1. 打开登录页面
2. 输入正确的fgedu和空密码
3. 点击登录按钮
– 预期结果：
– 显示密码不能为空的提示

# 安装JMeter
$ wget https://archive.apache.org/dist/jmeter/binaries/apache-jmeter-5.4.3.tgz
$ tar -xzf apache-jmeter-5.4.3.tgz
$ cd apache-jmeter-5.4.3

# 创建测试计划
$ cat test-plan.jmx





false
true
false






continue

false
10

10
5
false







fgedu.net.cn
80
http

/
GET
true
false
true
false






false

saveConfig

true
true
true
true
true
true
true true true
false
true
true
false
false
false
false
false
false
false
false
0
true
true
true true true
true


results.jtl

# 运行测试
$ ./bin/jmeter -n -t test-plan.jmx -l results.jtl

# 查看测试结果
$ ./bin/jmeter -g results.jtl -o report
# 打开报告目录中的index.html文件

# 创建LoadRunner脚本
$ cat web_test.lrs
Action()
{
web_url(“Example”,
“URL=http://fgedu.net.cn”,
“Resource=0”,
“RecContentType=text/html”,
“Referer=”,
“Snapshot=t1.inf”,
“Mode=HTML”,
LAST);

return 0;
}

# 配置LoadRunner场景
# 1. 打开LoadRunner Controller
# 2. 创建新场景
# 3. 添加脚本
# 4. 配置虚拟用户数和运行时间
# 5. 运行场景

# 查看测试结果
# LoadRunner Analysis

author:www.itpux.com

9. 安全测试

9.1 OWASP ZAP安全测试

# 安装OWASP ZAP
$ wget https://github.com/zaproxy/zaproxy/releases/download/v2.11.1/ZAP_2.11.1_Linux.tar.gz
$ tar -xzf ZAP_2.11.1_Linux.tar.gz
$ cd ZAP_2.11.1

# 运行ZAP
$ ./zap.sh

# 使用ZAP进行安全扫描
# 1. 打开ZAP
# 2. 点击”Quick Start”标签
# 3. 输入目标URL
# 4. 点击”Attack”

# 查看扫描结果
# ZAP界面 -> Alerts标签

# 使用ZAP API
$ curl -X POST “http://fgedudb:8080/JSON/core/action/accessUrl” \
-d ‘{“url”:”http://fgedu.net.cn”,”followRedirects”:true}’

$ curl -X POST “http://fgedudb:8080/JSON/ascan/action/scan” \
-d ‘{“url”:”http://fgedu.net.cn”,”recurse”:true,”inScopeOnly”:true,”scanPolicyName”:””,”method”:”POST”,”postData”:””}’

# 查看扫描状态
$ curl “http://fgedudb:8080/JSON/ascan/view/status?id=1”

# 安装Burp Suite
# 从官网下载并安装Burp Suite

# 配置Burp Suite
# 1. 打开Burp Suite
# 2. 配置代理设置
# 3. 配置浏览器使用Burp代理

# 进行安全测试
# 1. 浏览目标网站
# 2. 使用Burp Scanner进行扫描
# 3. 查看扫描结果

# 使用Burp Intruder进行暴力破解
# 1. 选择请求
# 2. 发送到Intruder
# 3. 配置攻击类型和payload
# 4. 开始攻击

# 使用Burp Repeater进行请求修改
# 1. 选择请求
# 2. 发送到Repeater
# 3. 修改请求
# 4. 发送请求并查看响应

# 安装Appium
$ npm install -g appium
$ npm install -g appium-doctor

# 检查Appium环境
$ appium-doctor

# 创建测试脚本
$ cat appium-test.js
const wd = require(‘wd’);

async function testCalculator() {
// 配置Appium
const driver = await wd.promiseChainRemote({
host: ‘fgedudb’,
port: 4723
});

// 启动应用
await driver.init({
platformName: ‘Android’,
platformVersion: ’11’,
deviceName: ’emulator-5554′,
app: ‘/path/to/calculator.apk’,
automationName: ‘UiAutomator2’
});

try {
// 点击数字按钮
await driver.elementById(‘com.android.calculator2:id/digit_2’).click();
await driver.elementById(‘com.android.calculator2:id/op_add’).click();
await driver.elementById(‘com.android.calculator2:id/digit_3’).click();
await driver.elementById(‘com.android.calculator2:id/eq’).click();

// 获取结果
const result = await driver.elementById(‘com.android.calculator2:id/result’).text();
console.log(`Result: ${result}`);

// 验证结果
if (result === ‘5’) {
console.log(‘Test passed!’);
} else {
console.log(‘Test failed!’);
}
} finally {
// 关闭应用
await driver.quit();
}
}

testCalculator();

# 启动Appium服务器
$ appium

# 运行测试
$ node appium-test.js

# 查看测试结果
Result: 5
Test passed!

# 创建Android测试项目
# 1. 打开Android Studio
# 2. 创建新项目
# 3. 添加Espresso依赖

# 创建测试类
$ cat CalculatorTest.java
import androidx.test.ext.junit.rules.ActivityScenarioRule;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import static androidx.test.espresso.Espresso.onView;
import static androidx.test.espresso.action.ViewActions.click;
import static androidx.test.espresso.assertion.ViewAssertions.matches;
import static androidx.test.espresso.matcher.ViewMatchers.withId;
import static androidx.test.espresso.matcher.ViewMatchers.withText;

@RunWith(AndroidJUnit4.class)
public class CalculatorTest {

@Rule
public ActivityScenarioRule activityRule =
new ActivityScenarioRule<>(MainActivity.class);

@Test
public void testAddition() {
// 点击数字2
onView(withId(R.id.digit_2)).perform(click());
// 点击加号
onView(withId(R.id.op_add)).perform(click());
// 点击数字3
onView(withId(R.id.digit_3)).perform(click());
// 点击等号
onView(withId(R.id.eq)).perform(click());
// 验证结果
onView(withId(R.id.result)).check(matches(withText(“5″)));
}
}

# 运行测试
# 1. 在Android Studio中右键点击测试类
# 2. 选择”Run ‘CalculatorTest'”

# 查看测试结果
# Android Studio -> Run窗口