465 lines
24 KiB
TypeScript
465 lines
24 KiB
TypeScript
import { beforeEach, describe, expect, it, vi } from 'vitest'
|
|
import { http } from '@/shared/api/http'
|
|
import {
|
|
approveEnterpriseReview,
|
|
archivePlatformTenant,
|
|
assignPlatformInternalUserRoles,
|
|
changePlatformManagedUserStatus,
|
|
changePlatformInternalUserStatus,
|
|
changePlatformTenantStatus,
|
|
changePlatformPermissionStatus,
|
|
changePlatformRoleStatus,
|
|
createPlatformPermission,
|
|
createPlatformManagedUser,
|
|
createPlatformRole,
|
|
createPlatformTenant,
|
|
createPlatformTenantImpersonation,
|
|
deletePlatformPermission,
|
|
deletePlatformRole,
|
|
downloadTenantQualification,
|
|
getPlatformTenantDimensionInitializationStatus,
|
|
listPlatformTenants,
|
|
listPlatformTenantOrderCounts,
|
|
listTenantQualifications,
|
|
listPlatformPermissions,
|
|
listPlatformRoles,
|
|
listPlatformInternalUsers,
|
|
listPlatformManagedUsers,
|
|
listSharedReceivingOverseasWarehouseOptions,
|
|
getPlatformUserOptions,
|
|
qualificationFileName,
|
|
replacePlatformRolePermissions,
|
|
resetPlatformInternalUserPassword,
|
|
resetPlatformManagedUserPassword,
|
|
resetPlatformTenantOwnerPassword,
|
|
submitPlatformTenantReview,
|
|
updatePlatformInternalUser,
|
|
updatePlatformManagedUser,
|
|
updatePlatformPermission,
|
|
updatePlatformRole,
|
|
updatePlatformTenant,
|
|
uploadPlatformTenantQualification,
|
|
uploadPlatformTenantRequiredQualificationPackage,
|
|
type PlatformPermissionResource,
|
|
type PlatformInternalUser,
|
|
type PlatformManagedUser,
|
|
type PlatformRoleResource,
|
|
} from './platformIam'
|
|
|
|
vi.mock('@/shared/api/http', () => ({
|
|
http: { get: vi.fn(), post: vi.fn(), put: vi.fn(), delete: vi.fn() },
|
|
unwrapApiResponse: <T>(response: { data: T }) => response.data,
|
|
}))
|
|
|
|
const role: PlatformRoleResource = {
|
|
id: 4000002,
|
|
tenantId: 0,
|
|
appCode: 'PLATFORM',
|
|
roleCode: 'CUSTOMER_REVIEWER',
|
|
roleName: '企业审核员',
|
|
roleType: 'SYSTEM',
|
|
status: 'ACTIVE',
|
|
description: '企业资料与入驻审核',
|
|
memberCount: 3,
|
|
permissionIds: ['5100010'],
|
|
}
|
|
|
|
const permission: PlatformPermissionResource = {
|
|
id: 5100010,
|
|
tenantId: 0,
|
|
appCode: 'PLATFORM',
|
|
permissionType: 'MENU',
|
|
parentId: 5100000,
|
|
permissionCode: 'platform:customer:list',
|
|
permissionName: '企业客户',
|
|
routePath: '/customers',
|
|
httpMethod: null,
|
|
sortNo: 10,
|
|
status: 'ACTIVE',
|
|
builtIn: false,
|
|
}
|
|
|
|
const internalUser: PlatformInternalUser = {
|
|
membershipId: 3000001,
|
|
userId: 2000001,
|
|
authUserId: 2000001,
|
|
username: 'platform_admin',
|
|
displayName: '平台管理员',
|
|
phone: '13800138000',
|
|
email: 'admin@example.com',
|
|
memberType: 'INTERNAL',
|
|
memberNo: 'PLATFORM-0001',
|
|
status: 'ACTIVE',
|
|
roleIds: [4000001],
|
|
}
|
|
|
|
const managedUser: PlatformManagedUser = {
|
|
membershipId: '3000002',
|
|
userId: '2000002',
|
|
authUserId: '1000002',
|
|
username: 'zhangwei',
|
|
displayName: '张伟',
|
|
phone: '13800138000',
|
|
email: 'zhangwei@example.com',
|
|
tenantId: '0',
|
|
tenantName: '平台',
|
|
memberType: 'INTERNAL',
|
|
memberNo: 'PLATFORM-3000002',
|
|
status: 'ACTIVE',
|
|
roleIds: ['40001'],
|
|
roleNames: ['运营管理员'],
|
|
lastLoginAt: '2026-06-01T10:30:00',
|
|
protectedAccount: false,
|
|
overseasWarehouseId: null,
|
|
}
|
|
|
|
describe('platform IAM roles', () => {
|
|
beforeEach(() => {
|
|
vi.mocked(http.get).mockReset()
|
|
vi.mocked(http.post).mockReset()
|
|
vi.mocked(http.put).mockReset()
|
|
vi.mocked(http.delete).mockReset()
|
|
})
|
|
|
|
it('loads roles from the platform IAM prefix', async () => {
|
|
vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: [role] })
|
|
|
|
await expect(listPlatformRoles()).resolves.toEqual([role])
|
|
expect(http.get).toHaveBeenCalledWith('/platform/v1/iam/roles')
|
|
})
|
|
|
|
it('creates a platform role with the documented payload', async () => {
|
|
const payload = {
|
|
roleCode: 'CUSTOMER_REVIEWER',
|
|
roleName: '企业审核员',
|
|
description: '企业资料与入驻审核',
|
|
}
|
|
vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: role })
|
|
|
|
await expect(createPlatformRole(payload)).resolves.toEqual(role)
|
|
expect(http.post).toHaveBeenCalledWith('/platform/v1/iam/roles', payload)
|
|
})
|
|
|
|
it('updates status, permissions, and deletes roles with the implemented IAM routes', async () => {
|
|
vi.mocked(http.put).mockResolvedValue({ code: '200', message: 'success', data: role })
|
|
vi.mocked(http.delete).mockResolvedValue({ code: '200', message: 'success', data: null })
|
|
|
|
await expect(updatePlatformRole(role.id, { roleName: '审核主管', description: '负责企业审核' })).resolves.toEqual(role)
|
|
await expect(changePlatformRoleStatus(role.id, 'DISABLED')).resolves.toEqual(role)
|
|
await expect(replacePlatformRolePermissions(role.id, ['5100010'])).resolves.toEqual(role)
|
|
await expect(deletePlatformRole(role.id)).resolves.toBeNull()
|
|
|
|
expect(http.put).toHaveBeenNthCalledWith(1, `/platform/v1/iam/roles/${role.id}`, { roleName: '审核主管', description: '负责企业审核' })
|
|
expect(http.put).toHaveBeenNthCalledWith(2, `/platform/v1/iam/roles/${role.id}/status`, { status: 'DISABLED' })
|
|
expect(http.put).toHaveBeenNthCalledWith(3, '/platform/v1/iam/roles/permissions', { roleId: role.id, permissionIds: ['5100010'] })
|
|
expect(http.delete).toHaveBeenCalledWith(`/platform/v1/iam/roles/${role.id}`)
|
|
})
|
|
|
|
it('loads and creates permission resources under the platform IAM prefix', async () => {
|
|
vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: [permission] })
|
|
vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: permission })
|
|
const payload = {
|
|
type: 'MENU' as const,
|
|
code: permission.permissionCode,
|
|
name: permission.permissionName,
|
|
parentId: permission.parentId,
|
|
routePath: permission.routePath,
|
|
httpMethod: null,
|
|
sortNo: permission.sortNo,
|
|
}
|
|
|
|
await expect(listPlatformPermissions()).resolves.toEqual([permission])
|
|
await expect(createPlatformPermission(payload)).resolves.toEqual(permission)
|
|
expect(http.get).toHaveBeenCalledWith('/platform/v1/iam/permissions')
|
|
expect(http.post).toHaveBeenCalledWith('/platform/v1/iam/permissions', payload)
|
|
})
|
|
|
|
it('updates, changes status, and deletes custom permission resources with IAM routes', async () => {
|
|
vi.mocked(http.put).mockResolvedValue({ code: '200', message: 'success', data: permission })
|
|
vi.mocked(http.delete).mockResolvedValue({ code: '200', message: 'success', data: null })
|
|
const payload = { name: '企业客户', parentId: permission.parentId, routePath: '/customers', httpMethod: null, sortNo: 10 }
|
|
|
|
await expect(updatePlatformPermission(permission.id, payload)).resolves.toEqual(permission)
|
|
await expect(changePlatformPermissionStatus(permission.id, 'DISABLED')).resolves.toEqual(permission)
|
|
await expect(deletePlatformPermission(permission.id)).resolves.toBeNull()
|
|
|
|
expect(http.put).toHaveBeenNthCalledWith(1, `/platform/v1/iam/permissions/${permission.id}`, payload)
|
|
expect(http.put).toHaveBeenNthCalledWith(2, `/platform/v1/iam/permissions/${permission.id}/status`, { status: 'DISABLED' })
|
|
expect(http.delete).toHaveBeenCalledWith(`/platform/v1/iam/permissions/${permission.id}`)
|
|
})
|
|
|
|
it('maintains internal users through their public membership ID', async () => {
|
|
vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: [internalUser] })
|
|
vi.mocked(http.put).mockResolvedValue({ code: '200', message: 'success', data: internalUser })
|
|
const update = {
|
|
displayName: '平台管理员',
|
|
phone: '13800138000',
|
|
email: 'admin@example.com',
|
|
memberNo: 'PLATFORM-0001',
|
|
roleIds: [4000001],
|
|
}
|
|
|
|
await expect(listPlatformInternalUsers()).resolves.toEqual([internalUser])
|
|
await expect(updatePlatformInternalUser(internalUser.membershipId, update)).resolves.toEqual(internalUser)
|
|
await expect(changePlatformInternalUserStatus(internalUser.membershipId, 'DISABLED')).resolves.toEqual(internalUser)
|
|
await expect(resetPlatformInternalUserPassword(internalUser.membershipId, 'ChangeMe123')).resolves.toEqual(internalUser)
|
|
await expect(assignPlatformInternalUserRoles(internalUser.membershipId, [4000001])).resolves.toEqual(internalUser)
|
|
|
|
expect(http.get).toHaveBeenCalledWith('/platform/v1/iam/internal-users')
|
|
expect(http.put).toHaveBeenNthCalledWith(1, `/platform/v1/iam/internal-users/${internalUser.membershipId}`, update)
|
|
expect(http.put).toHaveBeenNthCalledWith(2, `/platform/v1/iam/internal-users/${internalUser.membershipId}/status`, { status: 'DISABLED' })
|
|
expect(http.put).toHaveBeenNthCalledWith(3, `/platform/v1/iam/internal-users/${internalUser.membershipId}/password`, { newPassword: 'ChangeMe123' })
|
|
expect(http.put).toHaveBeenNthCalledWith(4, `/platform/v1/iam/internal-users/${internalUser.membershipId}/roles`, { roleIds: [4000001] })
|
|
})
|
|
|
|
it('maintains paginated platform users through the unified user contract', async () => {
|
|
const userOptionsPayload = {
|
|
tenants: [{ id: '0', name: '平台', status: 'ACTIVE' }],
|
|
roles: [{ id: '40001', tenantId: '0', name: '运营管理员', status: 'ACTIVE' }],
|
|
}
|
|
const userOptions = {
|
|
...userOptionsPayload,
|
|
roles: [{ ...userOptionsPayload.roles[0], roleCode: 'PLATFORM_OPERATOR' }],
|
|
}
|
|
const create = {
|
|
username: 'zhangwei', displayName: '张伟', phone: '13800138000', email: 'zhangwei@example.com',
|
|
tenantId: '0', roleIds: ['40001'], overseasWarehouseId: null, password: 'Password1', status: 'ACTIVE' as const,
|
|
}
|
|
const update = {
|
|
displayName: '张伟', phone: '13800138000', email: 'zhangwei@example.com',
|
|
tenantId: '0', roleIds: ['40001'], overseasWarehouseId: null,
|
|
}
|
|
const userPage = { records: [managedUser], page: 2, size: 10, total: 11, pages: 2 }
|
|
vi.mocked(http.get).mockResolvedValueOnce({
|
|
code: '200', message: 'success', data: { ...userPage, page: '2', size: '10', total: '11', pages: '2' },
|
|
})
|
|
.mockResolvedValueOnce({ code: '200', message: 'success', data: userOptionsPayload })
|
|
.mockResolvedValueOnce({
|
|
code: '200', message: 'success',
|
|
data: [{ ...role, id: '40001', roleCode: 'PLATFORM_OPERATOR' }],
|
|
})
|
|
vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: managedUser })
|
|
vi.mocked(http.put).mockResolvedValue({ code: '200', message: 'success', data: managedUser })
|
|
|
|
await expect(listPlatformManagedUsers({ page: 2, size: 10, keyword: '张伟', status: 'ACTIVE' })).resolves.toEqual(userPage)
|
|
await expect(getPlatformUserOptions()).resolves.toEqual(userOptions)
|
|
await expect(createPlatformManagedUser(create)).resolves.toEqual(managedUser)
|
|
await expect(updatePlatformManagedUser(managedUser.membershipId, update)).resolves.toEqual(managedUser)
|
|
await expect(changePlatformManagedUserStatus(managedUser.membershipId, 'DISABLED')).resolves.toEqual(managedUser)
|
|
await expect(resetPlatformManagedUserPassword(managedUser.membershipId, 'ChangeMe123')).resolves.toEqual(managedUser)
|
|
|
|
expect(http.get).toHaveBeenNthCalledWith(1, '/platform/v1/iam/users', {
|
|
params: { page: 2, size: 10, keyword: '张伟', status: 'ACTIVE' },
|
|
})
|
|
expect(http.get).toHaveBeenNthCalledWith(2, '/platform/v1/iam/users/options')
|
|
expect(http.get).toHaveBeenNthCalledWith(3, '/platform/v1/iam/roles')
|
|
expect(http.post).toHaveBeenCalledWith('/platform/v1/iam/users', create)
|
|
expect(http.put).toHaveBeenNthCalledWith(1, `/platform/v1/iam/users/${managedUser.membershipId}`, update)
|
|
expect(http.put).toHaveBeenNthCalledWith(2, `/platform/v1/iam/users/${managedUser.membershipId}/status`, { status: 'DISABLED' })
|
|
expect(http.put).toHaveBeenNthCalledWith(3, `/platform/v1/iam/users/${managedUser.membershipId}/password`, { newPassword: 'ChangeMe123' })
|
|
})
|
|
|
|
it('loads only active shared receiving overseas warehouses from domestic warehouse master data', async () => {
|
|
vi.mocked(http.get).mockResolvedValue({
|
|
code: '200', message: 'success', data: {
|
|
records: [
|
|
{ id: '90071992547409931', tenantId: '0', warehouseCode: 'LAX-01', warehouseName: '洛杉矶收货仓', warehouseType: 'OVERSEAS', countryCode: 'US', status: 'ACTIVE' },
|
|
{ id: '90071992547409932', tenantId: '0', warehouseCode: 'NYC-01', warehouseName: '纽约收货仓', warehouseType: 'OVERSEAS', countryCode: 'US', status: 'ACTIVE' },
|
|
{ id: '2', tenantId: '100', warehouseCode: 'CUST', warehouseName: '客户仓', warehouseType: 'OVERSEAS', countryCode: 'US', status: 'ACTIVE' },
|
|
{ id: '3', tenantId: '0', warehouseCode: 'PARTNER', warehouseName: '合作仓', warehouseType: 'OVERSEAS_PARTNER', countryCode: 'US', status: 'ACTIVE' },
|
|
{ id: '4', tenantId: '0', warehouseCode: 'ONT8', warehouseName: 'ONT8', warehouseType: 'FBA', countryCode: 'US', status: 'ACTIVE' },
|
|
{ id: '5', tenantId: '0', warehouseCode: 'SEA-INACTIVE', warehouseName: '西雅图停用仓', warehouseType: 'OVERSEAS', countryCode: 'US', status: 'INACTIVE' },
|
|
], page: 1, size: 200, total: 6, pages: 1,
|
|
},
|
|
})
|
|
|
|
await expect(listSharedReceivingOverseasWarehouseOptions()).resolves.toEqual([
|
|
{ id: '90071992547409931', warehouseCode: 'LAX-01', warehouseName: '洛杉矶收货仓', countryCode: 'US' },
|
|
{ id: '90071992547409932', warehouseCode: 'NYC-01', warehouseName: '纽约收货仓', countryCode: 'US' },
|
|
])
|
|
expect(http.get).toHaveBeenCalledWith('/platform/v1/warehouse-admin', {
|
|
params: {
|
|
tenantId: '0', page: 1, size: 200, capabilityCode: 'RECEIVING',
|
|
warehouseType: 'OVERSEAS', status: 'ACTIVE',
|
|
},
|
|
})
|
|
})
|
|
|
|
it('loads qualifications for the selected tenant', async () => {
|
|
const qualification = {
|
|
id: 12,
|
|
tenantId: 8,
|
|
qualificationType: 'BUSINESS_LICENSE',
|
|
certificateNo: '91440300XXXXXXXXXX',
|
|
documentUrl: '/api/merchant/v1/files/qualifications/license.png',
|
|
status: 'PENDING' as const,
|
|
reviewComment: null,
|
|
}
|
|
vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: [qualification] })
|
|
|
|
await expect(listTenantQualifications(8)).resolves.toEqual([qualification])
|
|
expect(http.get).toHaveBeenCalledWith('/platform/v1/iam/tenants/8/qualifications')
|
|
})
|
|
|
|
it('loads paginated tenants with the documented filters', async () => {
|
|
const page = { records: [], page: 2, size: 10, total: 11, pages: 2 }
|
|
vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: { ...page, page: '2', size: '10', total: '11', pages: '2' } })
|
|
|
|
await expect(listPlatformTenants({ page: 2, size: 10, keyword: '柏悦', status: 'ACTIVE' })).resolves.toEqual(page)
|
|
expect(http.get).toHaveBeenCalledWith('/platform/v1/iam/tenants', {
|
|
params: { page: 2, size: 10, keyword: '柏悦', status: 'ACTIVE' },
|
|
})
|
|
})
|
|
|
|
it('creates, updates, and changes customer status with the platform tenant contract', async () => {
|
|
const tenant = { id: '8', tenantCode: 'TEN8', tenantName: '柏悦物流', status: 'ACTIVE' }
|
|
const create = {
|
|
tenantName: '柏悦物流', customerNickname: '柏', legalName: '柏悦物流有限公司', legalRepresentative: '张三',
|
|
contactName: '张三', contactPhone: '13800138000', contactEmail: 'ops@example.com', servicePackage: '标准版',
|
|
contactWechat: 'baiyue-ops', salesOwnerName: '李四', paymentTermDays: 30, enterpriseType: '有限责任公司',
|
|
establishedDate: '2020-01-01', registeredCapital: 1000, registeredCapitalCurrency: 'CNY',
|
|
registeredAddress: '深圳市宝安区', internalRemark: '重点客户',
|
|
}
|
|
const creation = { tenant, administratorUsername: '13800138000', temporaryPassword: 'Password1234' }
|
|
vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: creation })
|
|
vi.mocked(http.put).mockResolvedValue({ code: '200', message: 'success', data: tenant })
|
|
|
|
await expect(createPlatformTenant(create)).resolves.toEqual(creation)
|
|
await expect(updatePlatformTenant('8', create)).resolves.toEqual(tenant)
|
|
await expect(changePlatformTenantStatus('8', 'DISABLED')).resolves.toEqual(tenant)
|
|
|
|
expect(http.post).toHaveBeenCalledWith('/platform/v1/iam/tenants', create)
|
|
expect(http.put).toHaveBeenNthCalledWith(1, '/platform/v1/iam/tenants/8', create)
|
|
expect(http.put).toHaveBeenNthCalledWith(2, '/platform/v1/iam/tenants/8/status', { status: 'DISABLED' })
|
|
})
|
|
|
|
it('supports owner password reset, logical archive, and audited impersonation contracts', async () => {
|
|
const password = { newPassword: 'NewPassword#2026', forceChangePassword: true }
|
|
const archivedTenant = { id: '190000000000000099', tenantCode: 'TEN99', tenantName: '测试客户', status: 'ARCHIVED' }
|
|
const impersonation = { code: 'ticket-code', ticketId: 'ticket-id', expiresIn: 60 }
|
|
vi.mocked(http.put).mockResolvedValue({ code: '200', message: 'success', data: null })
|
|
vi.mocked(http.post)
|
|
.mockResolvedValueOnce({ code: '200', message: 'success', data: archivedTenant })
|
|
.mockResolvedValueOnce({ code: '200', message: 'success', data: impersonation })
|
|
|
|
await expect(resetPlatformTenantOwnerPassword('190000000000000099', password)).resolves.toBeNull()
|
|
await expect(archivePlatformTenant('190000000000000099')).resolves.toEqual(archivedTenant)
|
|
await expect(createPlatformTenantImpersonation('190000000000000099', { reason: '客户问题排查' })).resolves.toEqual(impersonation)
|
|
|
|
expect(http.put).toHaveBeenCalledWith('/platform/v1/iam/tenants/190000000000000099/owner/password', password)
|
|
expect(http.post).toHaveBeenNthCalledWith(1, '/platform/v1/iam/tenants/190000000000000099/archive', {})
|
|
expect(http.post).toHaveBeenNthCalledWith(2, '/platform/v1/iam/tenants/190000000000000099/impersonation', { reason: '客户问题排查' })
|
|
})
|
|
|
|
it('loads real order totals for the visible customer tenants', async () => {
|
|
const counts = [{ tenantId: '8', orderCount: 12 }, { tenantId: '9', orderCount: 0 }]
|
|
vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: counts })
|
|
await expect(listPlatformTenantOrderCounts(['8', '9'])).resolves.toEqual(counts)
|
|
expect(http.get).toHaveBeenCalledWith('/platform/v1/orders/first-leg/tenant-counts?tenantIds=8,9')
|
|
})
|
|
|
|
it('uploads optional qualification metadata before explicitly submitting the customer review', async () => {
|
|
const uploadResult = { qualificationId: '91', reviewId: null, tenantStatus: 'PROFILE_REQUIRED', documentUrl: '/file.pdf' }
|
|
const tenant = { id: '8', tenantCode: 'TEN8', tenantName: '柏悦物流', status: 'PENDING' }
|
|
vi.mocked(http.post).mockResolvedValueOnce({ code: '200', message: 'success', data: uploadResult })
|
|
.mockResolvedValueOnce({ code: '200', message: 'success', data: tenant })
|
|
const file = new File(['%PDF-1.4'], '开户许可证.pdf', { type: 'application/pdf' })
|
|
|
|
await expect(uploadPlatformTenantQualification('8', 'BANK_ACCOUNT_LICENSE', file, '2030-12-31', undefined, true)).resolves.toEqual(uploadResult)
|
|
await expect(submitPlatformTenantReview('8')).resolves.toEqual(tenant)
|
|
|
|
const form = vi.mocked(http.post).mock.calls[0]?.[1] as FormData
|
|
expect(http.post).toHaveBeenNthCalledWith(1, '/platform/v1/files/qualifications/8', expect.any(FormData))
|
|
expect(form.get('file')).toBe(file)
|
|
expect(form.get('qualificationType')).toBe('BANK_ACCOUNT_LICENSE')
|
|
expect(form.get('validTo')).toBe('2030-12-31')
|
|
expect(form.get('certificateNo')).toBeNull()
|
|
expect(form.get('replace')).toBe('true')
|
|
expect(http.post).toHaveBeenNthCalledWith(2, '/platform/v1/iam/tenants/8/submit-review', {})
|
|
})
|
|
|
|
it('uploads the business license, credit code and optional legal-person ID in one package request', async () => {
|
|
const result = {
|
|
businessLicenseQualificationId: '91', legalPersonIdQualificationId: '92',
|
|
tenantStatus: 'PROFILE_REQUIRED', businessLicenseDocumentUrl: '/license.pdf',
|
|
legalPersonIdDocumentUrl: '/legal-person.png',
|
|
}
|
|
vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: result })
|
|
const businessLicense = new File(['%PDF-1.4'], '营业执照.pdf', { type: 'application/pdf' })
|
|
const legalPersonId = new File(['image'], '法人身份证.png', { type: 'image/png' })
|
|
|
|
await expect(uploadPlatformTenantRequiredQualificationPackage(
|
|
'8', businessLicense, legalPersonId, '91440300MA5ABCDE12', true, true,
|
|
)).resolves.toEqual(result)
|
|
|
|
const form = vi.mocked(http.post).mock.calls[0]?.[1] as FormData
|
|
expect(http.post).toHaveBeenCalledWith('/platform/v1/files/qualifications/8/required-package', form)
|
|
expect(form.get('businessLicense')).toBe(businessLicense)
|
|
expect(form.get('legalPersonId')).toBe(legalPersonId)
|
|
expect(form.get('unifiedSocialCreditCode')).toBe('91440300MA5ABCDE12')
|
|
expect(form.get('replaceBusinessLicense')).toBe('true')
|
|
expect(form.get('replaceLegalPersonId')).toBe('true')
|
|
})
|
|
|
|
it('loads the customer dimension initialization status before querying dimension rules', async () => {
|
|
const status = {
|
|
tenantId: '2098016473058967554', status: 'PENDING', attemptCount: 3,
|
|
nextRetryAt: '2026-09-10T20:04:00', lastErrorCode: 'S0503',
|
|
lastErrorMessage: 'Firstleg 服务暂时不可用', updatedAt: '2026-09-10T19:54:00',
|
|
}
|
|
vi.mocked(http.get).mockResolvedValue({ code: '200', message: 'success', data: status })
|
|
|
|
await expect(getPlatformTenantDimensionInitializationStatus(status.tenantId)).resolves.toEqual(status)
|
|
expect(http.get).toHaveBeenCalledWith(
|
|
'/platform/v1/iam/tenants/2098016473058967554/dimension-initialization',
|
|
)
|
|
})
|
|
|
|
it('omits the optional legal-person ID parts when only the business license is uploaded', async () => {
|
|
const result = {
|
|
businessLicenseQualificationId: '91', legalPersonIdQualificationId: null,
|
|
tenantStatus: 'PROFILE_REQUIRED', businessLicenseDocumentUrl: '/license.pdf',
|
|
legalPersonIdDocumentUrl: null,
|
|
}
|
|
vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: result })
|
|
const businessLicense = new File(['%PDF-1.4'], '营业执照.pdf', { type: 'application/pdf' })
|
|
|
|
await expect(uploadPlatformTenantRequiredQualificationPackage(
|
|
'8', businessLicense, null, '91440300MA5ABCDE12', true, false,
|
|
)).resolves.toEqual(result)
|
|
|
|
const form = vi.mocked(http.post).mock.calls[0]?.[1] as FormData
|
|
expect(form.get('businessLicense')).toBe(businessLicense)
|
|
expect(form.get('legalPersonId')).toBeNull()
|
|
expect(form.get('replaceBusinessLicense')).toBe('true')
|
|
expect(form.get('replaceLegalPersonId')).toBeNull()
|
|
})
|
|
|
|
it('preserves long review identifiers and returns one-time administrator credentials', async () => {
|
|
const reviewId = '190000000000000001'
|
|
const approval = {
|
|
tenantId: '190000000000000099',
|
|
administratorCreated: true,
|
|
administratorUsername: 'merchant_owner',
|
|
temporaryPassword: 'Temporary#2026',
|
|
}
|
|
vi.mocked(http.post).mockResolvedValue({ code: '200', message: 'success', data: approval })
|
|
|
|
await expect(approveEnterpriseReview(reviewId, '资料完整')).resolves.toEqual(approval)
|
|
expect(http.post).toHaveBeenCalledWith(`/platform/v1/iam/reviews/${reviewId}/approve`, { comment: '资料完整' })
|
|
})
|
|
|
|
it('downloads a qualification with the platform file endpoint and a safe filename', async () => {
|
|
const blob = new Blob(['image'], { type: 'image/png' })
|
|
vi.mocked(http.get).mockResolvedValue(blob)
|
|
|
|
expect(qualificationFileName('/api/merchant/v1/files/qualifications/%E8%90%A5%E4%B8%9A%E6%89%A7%E7%85%A7.png?token=ignored')).toBe('营业执照.png')
|
|
await expect(downloadTenantQualification(8, '/api/merchant/v1/files/qualifications/%E8%90%A5%E4%B8%9A%E6%89%A7%E7%85%A7.png')).resolves.toBe(blob)
|
|
expect(http.get).toHaveBeenCalledWith(
|
|
'/platform/v1/files/qualifications/8/%E8%90%A5%E4%B8%9A%E6%89%A7%E7%85%A7.png',
|
|
{ responseType: 'blob' },
|
|
)
|
|
expect(() => qualificationFileName('/api/merchant/v1/files/qualifications/%2Fetc%2Fpasswd')).toThrow('资质文件地址无效')
|
|
})
|
|
})
|