test(mp): service 层测试扩展 — health + consultation + request

新增 3 个测试文件(+23 个测试用例),总计 9 文件 75 测试:
- request.test.ts: HTTP 方法、查询参数构建、缓存、错误处理
- health.test.ts: 体征录入字段映射、日常监测、阈值查找
- consultation.test.ts: 咨询会话/消息 CRUD、已读标记

- 添加 vitest setup.ts mock @tarojs/taro 和 @tarojs/runtime
- vitest.config.ts 增加 setupFiles 配置

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
iven
2026-05-13 14:10:27 +08:00
parent b7efa51d5f
commit 935ca70dfa
5 changed files with 467 additions and 0 deletions

View File

@@ -0,0 +1,112 @@
import { describe, it, expect, beforeEach, vi } from 'vitest';
import '../helpers/mock-api';
import { api } from '@/services/request';
import {
listConsultations,
getSession,
listMessages,
sendMessage,
markSessionRead,
} from '@/services/consultation';
describe('consultation service', () => {
beforeEach(() => {
vi.clearAllMocks();
});
describe('listConsultations', () => {
it('calls api.get with correct path', async () => {
vi.mocked(api.get).mockResolvedValueOnce({ data: [], total: 0 });
await listConsultations();
expect(api.get).toHaveBeenCalledWith('/health/consultation-sessions', undefined);
});
it('passes pagination params', async () => {
vi.mocked(api.get).mockResolvedValueOnce({ data: [], total: 0 });
await listConsultations({ page: 2, page_size: 10 });
expect(api.get).toHaveBeenCalledWith('/health/consultation-sessions', {
page: 2,
page_size: 10,
});
});
});
describe('getSession', () => {
it('calls api.get with session id', async () => {
const mock = { id: 's-1', status: 'active' } as any;
vi.mocked(api.get).mockResolvedValueOnce(mock);
const result = await getSession('s-1');
expect(api.get).toHaveBeenCalledWith('/health/consultation-sessions/s-1');
expect(result).toEqual(mock);
});
});
describe('listMessages', () => {
it('calls api.get with session id and params', async () => {
vi.mocked(api.get).mockResolvedValueOnce({ data: [], total: 0 });
await listMessages('s-1', { page: 1, page_size: 20 });
expect(api.get).toHaveBeenCalledWith(
'/health/consultation-sessions/s-1/messages',
{ page: 1, page_size: 20 },
);
});
it('passes after_id for incremental loading', async () => {
vi.mocked(api.get).mockResolvedValueOnce({ data: [], total: 0 });
await listMessages('s-1', { after_id: 'm-50' });
expect(api.get).toHaveBeenCalledWith(
'/health/consultation-sessions/s-1/messages',
expect.objectContaining({ after_id: 'm-50' }),
);
});
});
describe('sendMessage', () => {
it('calls api.post with session_id, content_type and content', async () => {
const mockMsg = { id: 'm-1', content: 'hello' } as any;
vi.mocked(api.post).mockResolvedValueOnce(mockMsg);
const result = await sendMessage('s-1', 'hello');
expect(api.post).toHaveBeenCalledWith('/health/consultation-messages', {
session_id: 's-1',
content_type: 'text',
content: 'hello',
});
expect(result).toEqual(mockMsg);
});
it('supports custom content_type', async () => {
vi.mocked(api.post).mockResolvedValueOnce({} as any);
await sendMessage('s-1', '<img src="x"/>', 'html');
expect(api.post).toHaveBeenCalledWith('/health/consultation-messages', {
session_id: 's-1',
content_type: 'html',
content: '<img src="x"/>',
});
});
});
describe('markSessionRead', () => {
it('calls api.put with session id', async () => {
vi.mocked(api.put).mockResolvedValueOnce(undefined);
await markSessionRead('s-1');
expect(api.put).toHaveBeenCalledWith('/health/consultation-sessions/s-1/read');
});
});
});

View File

@@ -0,0 +1,180 @@
import { describe, it, expect, beforeEach, vi } from 'vitest';
import '../helpers/mock-api';
import { api } from '@/services/request';
import {
inputVitalSign,
getTodaySummary,
getTrend,
listDailyMonitoring,
createDailyMonitoring,
findThreshold,
DEFAULT_THRESHOLDS,
} from '@/services/health';
describe('health service', () => {
beforeEach(() => {
vi.clearAllMocks();
});
describe('getTodaySummary', () => {
it('calls api.get with correct path', async () => {
const mock = { blood_pressure: { systolic: 120, diastolic: 80, status: 'normal' } };
vi.mocked(api.get).mockResolvedValueOnce(mock);
const result = await getTodaySummary();
expect(api.get).toHaveBeenCalledWith('/health/vital-signs/today', {});
expect(result).toEqual(mock);
});
it('passes patient_id when provided', async () => {
vi.mocked(api.get).mockResolvedValueOnce({});
await getTodaySummary('p-123');
expect(api.get).toHaveBeenCalledWith('/health/vital-signs/today', { patient_id: 'p-123' });
});
});
describe('inputVitalSign', () => {
it('maps blood_pressure to morning fields', async () => {
vi.mocked(api.post).mockResolvedValueOnce({});
await inputVitalSign('p-1', {
indicator_type: 'blood_pressure',
value: 0,
extra: { systolic: 130, diastolic: 85 },
});
expect(api.post).toHaveBeenCalledWith(
'/health/patients/p-1/vital-signs',
expect.objectContaining({
systolic_bp_morning: 130,
diastolic_bp_morning: 85,
}),
);
});
it('maps blood_pressure_evening to evening fields', async () => {
vi.mocked(api.post).mockResolvedValueOnce({});
await inputVitalSign('p-1', {
indicator_type: 'blood_pressure_evening',
value: 0,
extra: { systolic: 125, diastolic: 80 },
});
expect(api.post).toHaveBeenCalledWith(
'/health/patients/p-1/vital-signs',
expect.objectContaining({
systolic_bp_evening: 125,
diastolic_bp_evening: 80,
}),
);
});
it('maps heart_rate and rounds value', async () => {
vi.mocked(api.post).mockResolvedValueOnce({});
await inputVitalSign('p-1', { indicator_type: 'heart_rate', value: 72.5 });
expect(api.post).toHaveBeenCalledWith(
'/health/patients/p-1/vital-signs',
expect.objectContaining({ heart_rate: 73 }),
);
});
it('maps spo2 and rounds value', async () => {
vi.mocked(api.post).mockResolvedValueOnce({});
await inputVitalSign('p-1', { indicator_type: 'spo2', value: 98.7 });
expect(api.post).toHaveBeenCalledWith(
'/health/patients/p-1/vital-signs',
expect.objectContaining({ spo2: 99 }),
);
});
it('includes notes when provided', async () => {
vi.mocked(api.post).mockResolvedValueOnce({});
await inputVitalSign('p-1', { indicator_type: 'weight', value: 65, note: '饭后' });
expect(api.post).toHaveBeenCalledWith(
'/health/patients/p-1/vital-signs',
expect.objectContaining({ weight: 65, notes: '饭后' }),
);
});
it('includes record_date as today', async () => {
vi.mocked(api.post).mockResolvedValueOnce({});
await inputVitalSign('p-1', { indicator_type: 'weight', value: 65 });
const callData = vi.mocked(api.post).mock.calls[0][1] as Record<string, unknown>;
expect(callData.record_date).toMatch(/^\d{4}-\d{2}-\d{2}$/);
});
});
describe('getTrend', () => {
it('calls api.get with indicator and range', async () => {
vi.mocked(api.get).mockResolvedValueOnce({ indicator: 'systolic_bp', data_points: [] });
await getTrend('systolic_bp', '7d');
expect(api.get).toHaveBeenCalledWith('/health/vital-signs/trend', {
indicator: 'systolic_bp',
range: '7d',
});
});
});
describe('listDailyMonitoring', () => {
it('calls api.get with patient id and pagination', async () => {
vi.mocked(api.get).mockResolvedValueOnce({ data: [], total: 0 });
await listDailyMonitoring('p-1', { page: 2, page_size: 10 });
expect(api.get).toHaveBeenCalledWith(
'/health/patients/p-1/daily-monitoring',
{ page: 2, page_size: 10 },
);
});
});
describe('createDailyMonitoring', () => {
it('calls api.post with monitoring data', async () => {
const input = {
patient_id: 'p-1',
record_date: '2026-05-13',
morning_bp_systolic: 130,
morning_bp_diastolic: 85,
};
vi.mocked(api.post).mockResolvedValueOnce({ id: 'dm-1', ...input });
await createDailyMonitoring(input);
expect(api.post).toHaveBeenCalledWith('/health/daily-monitoring', input);
});
});
describe('findThreshold', () => {
it('finds matching active threshold', () => {
const result = findThreshold(DEFAULT_THRESHOLDS, 'systolic_bp', 'high', 'warning');
expect(result).toBeDefined();
expect(result!.threshold_value).toBe(140);
});
it('returns undefined for inactive threshold', () => {
const thresholds = [{ ...DEFAULT_THRESHOLDS[0], is_active: false }];
const result = findThreshold(thresholds, 'systolic_bp', 'high', 'warning');
expect(result).toBeUndefined();
});
it('returns undefined when no match', () => {
const result = findThreshold(DEFAULT_THRESHOLDS, 'unknown_indicator', 'high');
expect(result).toBeUndefined();
});
});
});

View File

@@ -0,0 +1,151 @@
import { describe, it, expect, vi, beforeEach } from 'vitest';
// Mock @tarojs/taro
vi.mock('@tarojs/taro', () => ({
default: {
request: vi.fn(),
getStorageSync: vi.fn(() => ''),
setStorageSync: vi.fn(),
showToast: vi.fn(),
reLaunch: vi.fn(),
getCurrentPages: vi.fn(() => []),
},
}));
// Mock secure-storage to use simple values
vi.mock('@/utils/secure-storage', () => ({
secureGet: vi.fn((key: string) => {
const store: Record<string, string> = { access_token: 'test-token', tenant_id: 'test-tenant' };
return store[key] || '';
}),
secureSet: vi.fn(),
secureRemove: vi.fn(),
}));
import Taro from '@tarojs/taro';
import { api, clearRequestCache } from '@/services/request';
describe('request module', () => {
beforeEach(() => {
vi.clearAllMocks();
clearRequestCache();
});
describe('api.get', () => {
it('should call Taro.request with correct method and url', async () => {
const mockData = { success: true, data: { items: [] } };
vi.mocked(Taro.request).mockResolvedValue({ statusCode: 200, data: mockData } as any);
const result = await api.get('/health/patients', { page: 1 });
expect(Taro.request).toHaveBeenCalledWith(
expect.objectContaining({
url: expect.stringContaining('/health/patients?page=1'),
method: 'GET',
}),
);
});
it('should build query string from params', async () => {
vi.mocked(Taro.request).mockResolvedValue({ statusCode: 200, data: { success: true, data: null } } as any);
await api.get('/test', { foo: 'bar', baz: 42 });
const call = vi.mocked(Taro.request).mock.calls[0][0];
expect(call.url).toContain('foo=bar');
expect(call.url).toContain('baz=42');
});
it('should skip undefined and empty params', async () => {
vi.mocked(Taro.request).mockResolvedValue({ statusCode: 200, data: { success: true, data: null } } as any);
await api.get('/test', { foo: 'bar', empty: '', missing: undefined });
const call = vi.mocked(Taro.request).mock.calls[0][0];
expect(call.url).toContain('foo=bar');
expect(call.url).not.toContain('empty');
expect(call.url).not.toContain('missing');
});
it('should cache GET responses', async () => {
vi.mocked(Taro.request).mockResolvedValue({ statusCode: 200, data: { success: true, data: { id: '1' } } } as any);
const r1 = await api.get('/cached');
const r2 = await api.get('/cached');
expect(Taro.request).toHaveBeenCalledTimes(1);
expect(r1).toEqual(r2);
});
});
describe('api.post', () => {
it('should send POST with body', async () => {
vi.mocked(Taro.request).mockResolvedValue({ statusCode: 200, data: { success: true, data: { id: 'new' } } } as any);
await api.post('/health/patients', { name: 'Test' });
expect(Taro.request).toHaveBeenCalledWith(
expect.objectContaining({
method: 'POST',
data: { name: 'Test' },
}),
);
});
});
describe('api.put', () => {
it('should send PUT with body', async () => {
vi.mocked(Taro.request).mockResolvedValue({ statusCode: 200, data: { success: true, data: {} } } as any);
await api.put('/health/patients/p1', { name: 'Updated', version: 1 });
expect(Taro.request).toHaveBeenCalledWith(
expect.objectContaining({
method: 'PUT',
data: { name: 'Updated', version: 1 },
}),
);
});
});
describe('api.delete', () => {
it('should send DELETE request', async () => {
vi.mocked(Taro.request).mockResolvedValue({ statusCode: 200, data: { success: true, data: null } } as any);
await api.delete('/health/patients/p1');
expect(Taro.request).toHaveBeenCalledWith(
expect.objectContaining({ method: 'DELETE' }),
);
});
});
describe('error handling', () => {
it('should throw on 403 with permission error', async () => {
vi.mocked(Taro.request).mockResolvedValue({ statusCode: 403, data: {} } as any);
await expect(api.get('/forbidden')).rejects.toThrow('权限不足');
});
it('should throw on 500 with server error', async () => {
vi.mocked(Taro.request).mockResolvedValue({ statusCode: 500, data: {} } as any);
await expect(api.get('/error')).rejects.toThrow('服务器错误');
});
it('should throw on network error', async () => {
vi.mocked(Taro.request).mockRejectedValue({ errMsg: 'request:fail timeout' });
await expect(api.get('/timeout')).rejects.toThrow('网络超时');
});
it('should throw on API failure with message', async () => {
vi.mocked(Taro.request).mockResolvedValue({
statusCode: 200,
data: { success: false, message: '参数错误' },
} as any);
await expect(api.get('/bad-params')).rejects.toThrow('参数错误');
});
});
});

View File

@@ -0,0 +1,23 @@
// Global setup for Taro runtime compatibility in tests
// Mock @tarojs/taro before any module loads it
import { vi } from 'vitest';
vi.mock('@tarojs/taro', () => ({
default: {
getStorageSync: vi.fn(() => ''),
setStorageSync: vi.fn(),
removeStorageSync: vi.fn(),
showToast: vi.fn(),
hideToast: vi.fn(),
showLoading: vi.fn(),
hideLoading: vi.fn(),
request: vi.fn(),
reLaunch: vi.fn(),
navigateTo: vi.fn(),
redirectTo: vi.fn(),
switchTab: vi.fn(),
getCurrentPages: vi.fn(() => []),
},
}));
vi.mock('@tarojs/runtime', () => ({}));

View File

@@ -6,6 +6,7 @@ export default defineConfig({
environment: 'node',
include: ['__tests__/**/*.test.ts'],
globals: true,
setupFiles: ['__tests__/setup.ts'],
},
resolve: {
alias: {