614 lines
20 KiB
JavaScript
614 lines
20 KiB
JavaScript
/**
|
|
* 心理健康测评API测试脚本
|
|
* 使用Node.js和axios进行API测试
|
|
*
|
|
* @author Cursor AI
|
|
* @date 2025-07-02
|
|
*/
|
|
|
|
const axios = require('axios');
|
|
const fs = require('fs');
|
|
|
|
// 配置信息
|
|
const config = {
|
|
baseURL: 'http://localhost:8080',
|
|
timeout: 10000,
|
|
headers: {
|
|
'Content-Type': 'application/json'
|
|
}
|
|
};
|
|
|
|
// 测试结果记录
|
|
const testResults = {
|
|
total: 0,
|
|
passed: 0,
|
|
failed: 0,
|
|
skipped: 0,
|
|
details: []
|
|
};
|
|
|
|
// 创建axios实例
|
|
const api = axios.create(config);
|
|
|
|
// 存储登录后的token
|
|
let token = '';
|
|
// 存储测试过程中创建的测评ID
|
|
let evaluationId = null;
|
|
// 存储测试过程中创建的测评明细ID
|
|
let detailIds = [];
|
|
|
|
/**
|
|
* 登录获取token
|
|
*/
|
|
async function login() {
|
|
try {
|
|
console.log('===== 登录获取token =====');
|
|
const loginData = {
|
|
username: 'admin',
|
|
password: 'admin123',
|
|
code: '1234',
|
|
uuid: 'test-uuid'
|
|
};
|
|
|
|
const response = await api.post('/login', loginData);
|
|
if (response.data.code === 200) {
|
|
token = response.data.data.token;
|
|
api.defaults.headers.common['Authorization'] = `Bearer ${token}`;
|
|
console.log('登录成功，获取token成功');
|
|
return true;
|
|
} else {
|
|
console.error('登录失败:', response.data.msg);
|
|
return false;
|
|
}
|
|
} catch (error) {
|
|
console.error('登录异常:', error.message);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 记录测试结果
|
|
* @param {string} name 测试名称
|
|
* @param {boolean} passed 是否通过
|
|
* @param {string} message 测试消息
|
|
* @param {object} response 响应数据
|
|
*/
|
|
function recordTestResult(name, passed, message, response) {
|
|
testResults.total++;
|
|
if (passed) {
|
|
testResults.passed++;
|
|
console.log(`✅ ${name}: ${message}`);
|
|
} else {
|
|
testResults.failed++;
|
|
console.error(`❌ ${name}: ${message}`);
|
|
}
|
|
|
|
testResults.details.push({
|
|
name,
|
|
passed,
|
|
message,
|
|
response: response ? JSON.stringify(response) : null,
|
|
timestamp: new Date().toISOString()
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 测试获取专业和班级选项
|
|
*/
|
|
async function testGetMajorAndClassOptions() {
|
|
try {
|
|
console.log('\n===== 测试获取专业和班级选项 =====');
|
|
const response = await api.get('/xljk/evaluation/options/majorAndClass');
|
|
const passed = response.data.code === 200 &&
|
|
response.data.data &&
|
|
response.data.data.majors &&
|
|
response.data.data.classes;
|
|
|
|
recordTestResult('获取专业和班级选项', passed,
|
|
passed ? '成功获取专业和班级选项' : '获取专业和班级选项失败',
|
|
response.data);
|
|
|
|
return passed ? response.data.data : null;
|
|
} catch (error) {
|
|
recordTestResult('获取专业和班级选项', false, `异常: ${error.message}`, null);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试获取学期选项
|
|
*/
|
|
async function testGetSemesterOptions() {
|
|
try {
|
|
console.log('\n===== 测试获取学期选项 =====');
|
|
const response = await api.get('/xljk/evaluation/options/semester');
|
|
const passed = response.data.code === 200 &&
|
|
Array.isArray(response.data.data) &&
|
|
response.data.data.length > 0;
|
|
|
|
recordTestResult('获取学期选项', passed,
|
|
passed ? '成功获取学期选项' : '获取学期选项失败',
|
|
response.data);
|
|
|
|
return passed ? response.data.data : null;
|
|
} catch (error) {
|
|
recordTestResult('获取学期选项', false, `异常: ${error.message}`, null);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试创建测评
|
|
*/
|
|
async function testCreateEvaluation(options) {
|
|
try {
|
|
console.log('\n===== 测试创建测评 =====');
|
|
if (!options || !options.majors || !options.classes || !options.semesters) {
|
|
recordTestResult('创建测评', false, '缺少必要的选项数据', null);
|
|
return null;
|
|
}
|
|
|
|
// 选择第一个专业和班级
|
|
const major = options.majors[0];
|
|
const clazz = options.classes.find(c => c.majorId === major.id) || options.classes[0];
|
|
const semester = options.semesters[0];
|
|
|
|
const evaluationData = {
|
|
evaluationName: `${semester}${clazz.name}心理健康测评(测试)`,
|
|
majorId: major.id,
|
|
majorName: major.name,
|
|
classId: clazz.id,
|
|
className: clazz.name,
|
|
semester: semester,
|
|
remark: '自动化测试创建'
|
|
};
|
|
|
|
const response = await api.post('/xljk/evaluation', evaluationData);
|
|
const passed = response.data.code === 200 && response.data.data;
|
|
|
|
if (passed) {
|
|
evaluationId = response.data.data;
|
|
}
|
|
|
|
recordTestResult('创建测评', passed,
|
|
passed ? `成功创建测评，ID: ${evaluationId}` : '创建测评失败',
|
|
response.data);
|
|
|
|
return passed ? {
|
|
id: evaluationId,
|
|
majorId: major.id,
|
|
classId: clazz.id
|
|
} : null;
|
|
} catch (error) {
|
|
recordTestResult('创建测评', false, `异常: ${error.message}`, null);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试获取学生信息
|
|
*/
|
|
async function testGetStudents(classId) {
|
|
try {
|
|
console.log('\n===== 测试获取学生信息 =====');
|
|
if (!classId) {
|
|
recordTestResult('获取学生信息', false, '缺少班级ID', null);
|
|
return null;
|
|
}
|
|
|
|
const response = await api.get(`/xljk/evaluation/detail/students/${classId}`);
|
|
const passed = response.data.code === 200 &&
|
|
Array.isArray(response.data.data) &&
|
|
response.data.data.length > 0;
|
|
|
|
recordTestResult('获取学生信息', passed,
|
|
passed ? `成功获取班级(${classId})学生信息，共${response.data.data.length}条` : '获取学生信息失败',
|
|
response.data);
|
|
|
|
return passed ? response.data.data : null;
|
|
} catch (error) {
|
|
recordTestResult('获取学生信息', false, `异常: ${error.message}`, null);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试批量添加学生
|
|
*/
|
|
async function testBatchAddStudents(evaluationId, students) {
|
|
try {
|
|
console.log('\n===== 测试批量添加学生 =====');
|
|
if (!evaluationId || !students || !Array.isArray(students) || students.length === 0) {
|
|
recordTestResult('批量添加学生', false, '缺少测评ID或学生数据', null);
|
|
return false;
|
|
}
|
|
|
|
// 构造学生数据
|
|
const studentData = students.map(student => ({
|
|
evaluationId: evaluationId,
|
|
studentId: student.id,
|
|
studentNo: student.studentNo,
|
|
studentName: student.studentName,
|
|
gender: student.gender,
|
|
birthDate: student.birthDate,
|
|
phone: student.phone
|
|
}));
|
|
|
|
const response = await api.post('/xljk/evaluation/detail/batch', studentData);
|
|
const passed = response.data.code === 200;
|
|
|
|
recordTestResult('批量添加学生', passed,
|
|
passed ? `成功批量添加${studentData.length}个学生` : '批量添加学生失败',
|
|
response.data);
|
|
|
|
return passed;
|
|
} catch (error) {
|
|
recordTestResult('批量添加学生', false, `异常: ${error.message}`, null);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试查询测评详情
|
|
*/
|
|
async function testGetEvaluationDetail(evaluationId) {
|
|
try {
|
|
console.log('\n===== 测试查询测评详情 =====');
|
|
if (!evaluationId) {
|
|
recordTestResult('查询测评详情', false, '缺少测评ID', null);
|
|
return null;
|
|
}
|
|
|
|
const response = await api.get(`/xljk/evaluation/${evaluationId}`);
|
|
const passed = response.data.code === 200 &&
|
|
response.data.data &&
|
|
response.data.data.id === evaluationId;
|
|
|
|
recordTestResult('查询测评详情', passed,
|
|
passed ? `成功查询测评详情，名称: ${response.data.data.evaluationName}` : '查询测评详情失败',
|
|
response.data);
|
|
|
|
return passed ? response.data.data : null;
|
|
} catch (error) {
|
|
recordTestResult('查询测评详情', false, `异常: ${error.message}`, null);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试查询测评明细列表
|
|
*/
|
|
async function testGetEvaluationDetailList(evaluationId) {
|
|
try {
|
|
console.log('\n===== 测试查询测评明细列表 =====');
|
|
if (!evaluationId) {
|
|
recordTestResult('查询测评明细列表', false, '缺少测评ID', null);
|
|
return null;
|
|
}
|
|
|
|
const response = await api.get(`/xljk/evaluation/detail/evaluation/${evaluationId}`);
|
|
const passed = response.data.code === 200 &&
|
|
Array.isArray(response.data.data);
|
|
|
|
if (passed && response.data.data.length > 0) {
|
|
detailIds = response.data.data.map(item => item.id);
|
|
}
|
|
|
|
recordTestResult('查询测评明细列表', passed,
|
|
passed ? `成功查询测评明细列表，共${response.data.data.length}条` : '查询测评明细列表失败',
|
|
response.data);
|
|
|
|
return passed ? response.data.data : null;
|
|
} catch (error) {
|
|
recordTestResult('查询测评明细列表', false, `异常: ${error.message}`, null);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试批量更新学生心理状态
|
|
*/
|
|
async function testBatchUpdateMentalStatus(details) {
|
|
try {
|
|
console.log('\n===== 测试批量更新学生心理状态 =====');
|
|
if (!details || !Array.isArray(details) || details.length === 0) {
|
|
recordTestResult('批量更新学生心理状态', false, '缺少测评明细数据', null);
|
|
return false;
|
|
}
|
|
|
|
// 构造更新数据，随机分配心理状态
|
|
const updateData = details.map((detail, index) => {
|
|
const status = (index % 3 + 1).toString();
|
|
return {
|
|
id: detail.id,
|
|
mentalStatus: status,
|
|
score: status === '3' ? Math.floor(Math.random() * 30) + 70 : null,
|
|
remark: status === '3' ? '需要重点关注' : null
|
|
};
|
|
});
|
|
|
|
const response = await api.put('/xljk/evaluation/detail/batch/mentalStatus', updateData);
|
|
const passed = response.data.code === 200;
|
|
|
|
recordTestResult('批量更新学生心理状态', passed,
|
|
passed ? `成功批量更新${updateData.length}个学生心理状态` : '批量更新学生心理状态失败',
|
|
response.data);
|
|
|
|
return passed;
|
|
} catch (error) {
|
|
recordTestResult('批量更新学生心理状态', false, `异常: ${error.message}`, null);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试发布测评
|
|
*/
|
|
async function testPublishEvaluation(evaluationId) {
|
|
try {
|
|
console.log('\n===== 测试发布测评 =====');
|
|
if (!evaluationId) {
|
|
recordTestResult('发布测评', false, '缺少测评ID', null);
|
|
return false;
|
|
}
|
|
|
|
const response = await api.put(`/xljk/evaluation/${evaluationId}/publish`);
|
|
const passed = response.data.code === 200;
|
|
|
|
recordTestResult('发布测评', passed,
|
|
passed ? '成功发布测评' : '发布测评失败',
|
|
response.data);
|
|
|
|
return passed;
|
|
} catch (error) {
|
|
recordTestResult('发布测评', false, `异常: ${error.message}`, null);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试完成测评
|
|
*/
|
|
async function testCompleteEvaluation(evaluationId) {
|
|
try {
|
|
console.log('\n===== 测试完成测评 =====');
|
|
if (!evaluationId) {
|
|
recordTestResult('完成测评', false, '缺少测评ID', null);
|
|
return false;
|
|
}
|
|
|
|
const response = await api.put(`/xljk/evaluation/${evaluationId}/complete`);
|
|
const passed = response.data.code === 200;
|
|
|
|
recordTestResult('完成测评', passed,
|
|
passed ? '成功完成测评' : '完成测评失败',
|
|
response.data);
|
|
|
|
return passed;
|
|
} catch (error) {
|
|
recordTestResult('完成测评', false, `异常: ${error.message}`, null);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试获取测评统计数据
|
|
*/
|
|
async function testGetEvaluationStatistics(evaluationId) {
|
|
try {
|
|
console.log('\n===== 测试获取测评统计数据 =====');
|
|
if (!evaluationId) {
|
|
recordTestResult('获取测评统计数据', false, '缺少测评ID', null);
|
|
return null;
|
|
}
|
|
|
|
const response = await api.get(`/xljk/evaluation/${evaluationId}/statistics`);
|
|
const passed = response.data.code === 200 &&
|
|
response.data.data &&
|
|
response.data.data.totalCount > 0;
|
|
|
|
recordTestResult('获取测评统计数据', passed,
|
|
passed ? `成功获取测评统计数据，总人数: ${response.data.data.totalCount}` : '获取测评统计数据失败',
|
|
response.data);
|
|
|
|
return passed ? response.data.data : null;
|
|
} catch (error) {
|
|
recordTestResult('获取测评统计数据', false, `异常: ${error.message}`, null);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试获取重点关注学生列表
|
|
*/
|
|
async function testGetFocusStudents() {
|
|
try {
|
|
console.log('\n===== 测试获取重点关注学生列表 =====');
|
|
|
|
const response = await api.get('/xljk/evaluation/detail/focus');
|
|
const passed = response.data.code === 200;
|
|
|
|
recordTestResult('获取重点关注学生列表', passed,
|
|
passed ? `成功获取重点关注学生列表，共${response.data.data.total}条` : '获取重点关注学生列表失败',
|
|
response.data);
|
|
|
|
return passed ? response.data.data : null;
|
|
} catch (error) {
|
|
recordTestResult('获取重点关注学生列表', false, `异常: ${error.message}`, null);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试获取重点关注学生统计
|
|
*/
|
|
async function testGetFocusStudentsStatistics() {
|
|
try {
|
|
console.log('\n===== 测试获取重点关注学生统计 =====');
|
|
|
|
const response = await api.get('/xljk/evaluation/statistics/focus');
|
|
const passed = response.data.code === 200 &&
|
|
response.data.data;
|
|
|
|
recordTestResult('获取重点关注学生统计', passed,
|
|
passed ? `成功获取重点关注学生统计，总关注率: ${response.data.data.totalFocusRate}%` : '获取重点关注学生统计失败',
|
|
response.data);
|
|
|
|
return passed ? response.data.data : null;
|
|
} catch (error) {
|
|
recordTestResult('获取重点关注学生统计', false, `异常: ${error.message}`, null);
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 测试删除测评
|
|
*/
|
|
async function testDeleteEvaluation(evaluationId) {
|
|
try {
|
|
console.log('\n===== 测试删除测评 =====');
|
|
if (!evaluationId) {
|
|
recordTestResult('删除测评', false, '缺少测评ID', null);
|
|
return false;
|
|
}
|
|
|
|
const response = await api.delete(`/xljk/evaluation/${evaluationId}`);
|
|
// 注意：由于测评已完成，删除应该会失败，这是符合预期的
|
|
const expectedFail = response.data.code !== 200;
|
|
|
|
recordTestResult('删除测评', expectedFail,
|
|
expectedFail ? '测评已完成，无法删除，符合预期' : '错误地成功删除了已完成的测评',
|
|
response.data);
|
|
|
|
return expectedFail;
|
|
} catch (error) {
|
|
// 如果是因为业务规则导致的错误（如已完成的测评不能删除），也算测试通过
|
|
const isBusinessError = error.response && error.response.data && error.response.data.code !== 200;
|
|
recordTestResult('删除测评', isBusinessError,
|
|
isBusinessError ? '测评已完成，无法删除，符合预期' : `异常: ${error.message}`,
|
|
error.response ? error.response.data : null);
|
|
return isBusinessError;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 输出测试报告
|
|
*/
|
|
function printTestReport() {
|
|
console.log('\n===== 测试报告 =====');
|
|
console.log(`总测试数: ${testResults.total}`);
|
|
console.log(`通过数: ${testResults.passed}`);
|
|
console.log(`失败数: ${testResults.failed}`);
|
|
console.log(`跳过数: ${testResults.skipped}`);
|
|
console.log(`通过率: ${Math.round(testResults.passed / testResults.total * 100)}%`);
|
|
|
|
// 将测试结果写入文件
|
|
const reportFile = `test_report_${new Date().toISOString().replace(/[:.]/g, '-')}.json`;
|
|
fs.writeFileSync(reportFile, JSON.stringify(testResults, null, 2));
|
|
console.log(`测试报告已保存到: ${reportFile}`);
|
|
}
|
|
|
|
/**
|
|
* 主测试流程
|
|
*/
|
|
async function runTests() {
|
|
console.log('===== 心理健康测评API测试开始 =====');
|
|
|
|
// 登录获取token
|
|
const loginSuccess = await login();
|
|
if (!loginSuccess) {
|
|
console.error('登录失败，无法继续测试');
|
|
return;
|
|
}
|
|
|
|
// 获取选项数据
|
|
const majorAndClassOptions = await testGetMajorAndClassOptions();
|
|
const semesterOptions = await testGetSemesterOptions();
|
|
|
|
if (!majorAndClassOptions || !semesterOptions) {
|
|
console.error('获取基础数据失败，无法继续测试');
|
|
return;
|
|
}
|
|
|
|
const options = {
|
|
majors: majorAndClassOptions.majors,
|
|
classes: majorAndClassOptions.classes,
|
|
semesters: semesterOptions
|
|
};
|
|
|
|
// 创建测评
|
|
const evaluationInfo = await testCreateEvaluation(options);
|
|
if (!evaluationInfo) {
|
|
console.error('创建测评失败，无法继续测试');
|
|
return;
|
|
}
|
|
|
|
// 获取学生信息
|
|
const students = await testGetStudents(evaluationInfo.classId);
|
|
if (!students) {
|
|
console.error('获取学生信息失败，无法继续测试');
|
|
return;
|
|
}
|
|
|
|
// 批量添加学生
|
|
const addSuccess = await testBatchAddStudents(evaluationInfo.id, students);
|
|
if (!addSuccess) {
|
|
console.error('批量添加学生失败，无法继续测试');
|
|
return;
|
|
}
|
|
|
|
// 查询测评详情
|
|
await testGetEvaluationDetail(evaluationInfo.id);
|
|
|
|
// 查询测评明细列表
|
|
const details = await testGetEvaluationDetailList(evaluationInfo.id);
|
|
if (!details) {
|
|
console.error('查询测评明细列表失败，无法继续测试');
|
|
return;
|
|
}
|
|
|
|
// 批量更新学生心理状态
|
|
const updateSuccess = await testBatchUpdateMentalStatus(details);
|
|
if (!updateSuccess) {
|
|
console.error('批量更新学生心理状态失败，无法继续测试');
|
|
return;
|
|
}
|
|
|
|
// 发布测评
|
|
const publishSuccess = await testPublishEvaluation(evaluationInfo.id);
|
|
if (!publishSuccess) {
|
|
console.error('发布测评失败，无法继续测试');
|
|
return;
|
|
}
|
|
|
|
// 完成测评
|
|
const completeSuccess = await testCompleteEvaluation(evaluationInfo.id);
|
|
if (!completeSuccess) {
|
|
console.error('完成测评失败，无法继续测试');
|
|
return;
|
|
}
|
|
|
|
// 获取测评统计数据
|
|
await testGetEvaluationStatistics(evaluationInfo.id);
|
|
|
|
// 获取重点关注学生列表
|
|
await testGetFocusStudents();
|
|
|
|
// 获取重点关注学生统计
|
|
await testGetFocusStudentsStatistics();
|
|
|
|
// 测试删除测评（应该失败，因为已完成）
|
|
await testDeleteEvaluation(evaluationInfo.id);
|
|
|
|
// 输出测试报告
|
|
printTestReport();
|
|
|
|
console.log('===== 心理健康测评API测试结束 =====');
|
|
}
|
|
|
|
// 运行测试
|
|
runTests().catch(error => {
|
|
console.error('测试过程中发生异常:', error);
|
|
printTestReport();
|
|
});
|