chore: 清理旧测试基础设施与废弃文件

- 移除 everything-is-suitable-test/ 旧测试框架
- 移除根目录 test-automation/、test-data-manager/、test-monitoring/
- 移除根目录 scripts/ 旧部署/测试脚本
- 移除 everything-is-suitable-uniapp/src/utils/httpClient.ts、tokenManager.ts
- 移除根目录旧配置文件(jest.config.js、package.json、tsconfig.json 等)
- 移除临时测试文件(test-*.ts、test-*.html、playwright-diagnose-*.js)
This commit is contained in:
张翔
2026-04-29 21:18:21 +08:00
parent a39b4388f3
commit 039fbe4f4c
1545 changed files with 2 additions and 223201 deletions
@@ -1,195 +0,0 @@
import appConfig from '../../config'
import type { ApiResult } from '../types/api'
export enum ErrorType {
NETWORK_ERROR = 'NETWORK_ERROR',
TIMEOUT_ERROR = 'TIMEOUT_ERROR',
BUSINESS_ERROR = 'BUSINESS_ERROR',
AUTH_ERROR = 'AUTH_ERROR',
TOKEN_EXPIRED = 'TOKEN_EXPIRED',
UNKNOWN_ERROR = 'UNKNOWN_ERROR'
}
export interface ApiError {
type: ErrorType
code: number
message: string
detail?: any
}
export interface RequestConfig {
url: string
method: 'GET' | 'POST' | 'PUT' | 'DELETE'
data?: any
params?: any
headers?: Record<string, string>
timeout?: number
needAuth?: boolean
}
class HttpClient {
private baseURL: string
private defaultTimeout: number = 10000
private tokenKey: string = 'auth_token'
constructor() {
this.baseURL = appConfig.baseURL
}
async request<T>(config: RequestConfig): Promise<ApiResult<T>> {
const { url, method, data, params, headers = {}, timeout = this.defaultTimeout, needAuth = true } = config
const requestUrl = this.buildUrl(url, params)
const requestHeaders = this.buildHeaders(headers, needAuth)
return new Promise((resolve, reject) => {
uni.request({
url: requestUrl,
method,
data,
header: requestHeaders,
timeout,
success: (response: any) => {
try {
const result = this.handleResponse<T>(response)
resolve(result)
} catch (error) {
reject(error)
}
},
fail: (error: any) => {
reject(this.handleError(error))
}
})
})
}
async get<T>(url: string, params?: any, options?: { needAuth?: boolean }): Promise<ApiResult<T>> {
return this.request<T>({ url, method: 'GET', params, ...options })
}
async post<T>(url: string, data?: any, options?: { needAuth?: boolean }): Promise<ApiResult<T>> {
return this.request<T>({ url, method: 'POST', data, ...options })
}
async put<T>(url: string, data?: any, options?: { needAuth?: boolean }): Promise<ApiResult<T>> {
return this.request<T>({ url, method: 'PUT', data, ...options })
}
async delete<T>(url: string, params?: any, options?: { needAuth?: boolean }): Promise<ApiResult<T>> {
return this.request<T>({ url, method: 'DELETE', params, ...options })
}
private buildUrl(url: string, params?: any): string {
let fullUrl = url.startsWith('http') ? url : `${this.baseURL}${url}`
if (params) {
const queryString = Object.keys(params)
.map(key => `${encodeURIComponent(key)}=${encodeURIComponent(params[key])}`)
.join('&')
fullUrl += `?${queryString}`
}
return fullUrl
}
private buildHeaders(headers: Record<string, string>, needAuth: boolean): Record<string, string> {
const requestHeaders: Record<string, string> = {
'Content-Type': 'application/json',
...headers
}
if (needAuth) {
const token = this.getToken()
if (token) {
requestHeaders['Authorization'] = `Bearer ${token}`
}
}
return requestHeaders
}
private handleResponse<T>(response: any): ApiResult<T> {
const { statusCode, data } = response
if (statusCode === 200) {
return data as ApiResult<T>
} else if (statusCode === 401) {
throw {
type: ErrorType.AUTH_ERROR,
code: 401,
message: '认证失败,请重新登录'
} as ApiError
} else if (statusCode === 400 || statusCode === 500) {
const errorMessage = data?.message || '请求失败'
throw {
type: ErrorType.BUSINESS_ERROR,
code: statusCode,
message: errorMessage
} as ApiError
} else {
throw {
type: ErrorType.UNKNOWN_ERROR,
code: statusCode,
message: '未知错误'
} as ApiError
}
}
private handleError(error: any): ApiError {
if (error.errMsg) {
if (error.errMsg.includes('timeout')) {
return {
type: ErrorType.TIMEOUT_ERROR,
code: 0,
message: '请求超时,请稍后重试'
}
} else if (error.errMsg.includes('fail')) {
return {
type: ErrorType.NETWORK_ERROR,
code: 0,
message: '网络连接失败,请检查网络设置'
}
}
}
if (error.type) {
return error as ApiError
}
return {
type: ErrorType.UNKNOWN_ERROR,
code: 0,
message: error.message || '未知错误'
}
}
private getToken(): string | null {
try {
return uni.getStorageSync(this.tokenKey) || null
} catch (error) {
return null
}
}
setToken(token: string): void {
try {
uni.setStorageSync(this.tokenKey, token)
} catch (error) {
console.error('设置Token失败:', error)
}
}
removeToken(): void {
try {
uni.removeStorageSync(this.tokenKey)
} catch (error) {
console.error('删除Token失败:', error)
}
}
}
const httpClient = new HttpClient()
export default httpClient
export { HttpClient }
@@ -1,93 +0,0 @@
import type { ApiError, ErrorType } from './httpClient'
const TOKEN_KEY = 'auth_token'
const REFRESH_TOKEN_KEY = 'refresh_token'
const TOKEN_EXPIRY_KEY = 'token_expiry'
class TokenManager {
setToken(token: string, expiresIn?: number): void {
try {
uni.setStorageSync(TOKEN_KEY, token)
if (expiresIn !== undefined) {
const expiryTime = Date.now() + expiresIn * 1000
uni.setStorageSync(TOKEN_EXPIRY_KEY, expiryTime)
}
} catch (error) {
console.error('设置Token失败:', error)
}
}
getToken(): string | null {
try {
const token = uni.getStorageSync(TOKEN_KEY)
if (token === null || token === undefined) {
return null
}
return token
} catch (error) {
console.error('获取Token失败:', error)
return null
}
}
removeToken(): void {
try {
uni.removeStorageSync(TOKEN_KEY)
uni.removeStorageSync(TOKEN_EXPIRY_KEY)
} catch (error) {
console.error('删除Token失败:', error)
}
}
setRefreshToken(refreshToken: string): void {
try {
uni.setStorageSync(REFRESH_TOKEN_KEY, refreshToken)
} catch (error) {
console.error('设置刷新Token失败:', error)
}
}
getRefreshToken(): string | null {
try {
const refreshToken = uni.getStorageSync(REFRESH_TOKEN_KEY)
if (refreshToken === null || refreshToken === undefined) {
return null
}
return refreshToken
} catch (error) {
console.error('获取刷新Token失败:', error)
return null
}
}
removeRefreshToken(): void {
try {
uni.removeStorageSync(REFRESH_TOKEN_KEY)
} catch (error) {
console.error('删除刷新Token失败:', error)
}
}
isTokenExpired(): boolean {
try {
const expiryTime = uni.getStorageSync(TOKEN_EXPIRY_KEY)
if (expiryTime === null || expiryTime === undefined) {
return false
}
return Date.now() >= expiryTime
} catch (error) {
console.error('检查Token过期失败:', error)
return false
}
}
clearAll(): void {
this.removeToken()
this.removeRefreshToken()
}
}
const tokenManager = new TokenManager()
export default tokenManager
export { TokenManager }