gongxiangp2/lib/__tests__/performance-salary-details.test.ts

230 lines
20 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/** @jest-environment node */
import { Prisma } from '@prisma/client'
import { prisma } from '../prisma'
import { requireSalaryAccess } from '../personnel-salary'
import { getPerformanceSalaryDetails } from '../performance-salary-details'
import { readSalaryWorkflowMetrics } from '../performance-salary-workflows'
import { readSalaryMarketIntent } from '../salary-market-intent'
import { INITIAL_SALARY_POSITIONS } from '../salary-position-seeds'
import { summarizeMarketIntent, type MarketIntentCandidate } from '../salary-market-intent-contract'
jest.mock('../prisma', () => ({ prisma: { $transaction: jest.fn(), organizationUnit: { findMany: jest.fn() }, salaryPositionConfig: { findMany: jest.fn() }, performanceSurveyEmployeeProfile: { findMany: jest.fn() }, personnelSalaryBase: { findMany: jest.fn() }, performanceSurveyResponse: { count: jest.fn(), findMany: jest.fn() } } }))
jest.mock('../personnel-salary', () => ({ requireSalaryAccess: jest.fn() }))
jest.mock('../performance-salary-workflows', () => ({ readSalaryWorkflowMetrics: jest.fn() }))
jest.mock('../salary-market-intent', () => ({ readSalaryMarketIntent: jest.fn() }))
const db = prisma as unknown as Record<string, any>
const workflow = readSalaryWorkflowMetrics as jest.Mock
let responseSequence = 0
const response = (id: string, code: string, totalScore: number) => ({ id: `response-${++responseSequence}`, totalScore, createdAt: new Date(), scores: {}, assignment: { workflowStageKey: 'review' }, target: { employeeProfileId: id }, survey: { templateCode: code, templateSnapshot: { code, questions: [], workflow: { scoring: { mode: 'average_reviewers', stageKeys: ['review'] } } } } })
const oldEnv = process.env.NODE_ENV
const positions = () => INITIAL_SALARY_POSITIONS.map((item, index) => ({ ...JSON.parse(JSON.stringify(item.value)), id: `job${index}`, revision: 1, updatedAt: new Date(), createdAt: new Date(), deletedAt: null }))
beforeEach(() => {
jest.resetAllMocks()
Object.assign(process.env, { NODE_ENV: 'development', PERFORMANCE_SALARY_LOCAL_TEST_FALLBACK: 'false' })
db.$transaction.mockImplementation((work: any) => work(prisma))
db.performanceSurveyResponse.count.mockResolvedValue(0)
db.performanceSurveyResponse.findMany.mockResolvedValue([response('p1', 'visual_brand_tone', 80), response('p1', 'visual_brand_tone', 100), response('p1', 'work_cooperation', 60), response('p1', 'project_result_validation', 100)])
db.performanceSurveyEmployeeProfile.findMany.mockResolvedValue([{ id: 'p1', realName: '档案名字', flowerName: '档案花名', displayName: 'HR名字', employmentState: 'ACTIVE', departmentPath: '公司/配置部门' }, { id: 'not-configured' }])
db.organizationUnit.findMany.mockResolvedValue([{ sourceDeptId: 1, name: '配置部门', path: '公司/配置部门' }])
db.salaryPositionConfig.findMany.mockResolvedValue(positions())
db.personnelSalaryBase.findMany.mockResolvedValue([{ positionId: 'job1', employeeProfileId: 'p1', name: '档案名字', flowerName: '档案花名', department: '配置部门', brand: '自由品牌', baseSalary: new Prisma.Decimal('100.01'), gradeSalary: new Prisma.Decimal('20'), performanceSalary: new Prisma.Decimal('30') }])
workflow.mockResolvedValue({ sourceMonth: '2026-10', points: new Map([['p1', 71]]), deliveryCounts: new Map([['p1', { onTime: 9, total: 10 }]]), onTimeRates: new Map([['p1', 90]]) })
;(readSalaryMarketIntent as jest.Mock).mockResolvedValue(new Map([['p1', { rawScore: 100, selected: [], averageChange: 0, validCount: 1 }]]))
})
afterAll(() => { Object.assign(process.env, { NODE_ENV: oldEnv }); delete process.env.PERFORMANCE_SALARY_LOCAL_TEST_FALLBACK })
test('配置快照关联人员、重复已提交调研取平均、工资及积分不变', async () => {
const data = await getPerformanceSalaryDetails('reader', '2026-10')
expect(requireSalaryAccess).toHaveBeenCalledWith('reader')
expect(data).toMatchObject({ displayMonth: '2026-10', sourceMonth: '2026-10', marketSourceMonth: '2026-09', isFallback: false })
expect(db.$transaction).toHaveBeenCalledWith(expect.any(Function), { isolationLevel: 'RepeatableRead' })
expect(db.performanceSurveyResponse.findMany.mock.calls[0][0].where).toEqual({ survey: { assessmentMonth: '2026-10', status: { notIn: ['draft', 'cancelled'] } }, assignment: { status: 'submitted' } })
expect(Object.values(data.roles).flat()).toHaveLength(1)
expect(data.roles['ai-planning'][0]).toMatchObject({ totalScore: 89.2, values: { name: '档案名字', baseSalary: '100.01', points: 71, performanceScore: 89.2, performanceCoefficient: .89, currentTotal: '146.71' } })
expect(data.positionGroups[1].position.revision).toBe(1)
const row = data.roles['ai-planning'][0]
const dimensions = data.positionGroups[1].position.dimensions
expect(row.metrics[dimensions[0].metrics[0].id]).toBe(90)
expect(row.values[`${dimensions[0].metrics[0].id}RawValue`]).toBe(90)
expect(row.values[`${dimensions[0].metrics[0].id}Score`]).toBe(22.5)
expect(row.values[`${dimensions[1].metrics[1].id}RawValue`]).toBe(90)
expect(row.values[`${dimensions[1].metrics[1].id}Score`]).toBe(56.7)
for (const [key, rawValue] of Object.entries(row.metrics)) expect(row.values[`${key}RawValue`]).toBe(rawValue)
expect(Object.keys(row.values).some(key => key.endsWith('Weighted'))).toBe(false)
})
test('只展示有基础档案且关联有效薪资岗位的人,无岗位人员不显示', async () => {
expect((await getPerformanceSalaryDetails('reader', '2026-09')).roles['ai-planning'][0].employeeProfileId).toBe('p1')
db.personnelSalaryBase.findMany.mockResolvedValue([{ positionId: null }, { positionId: 'deleted' }])
expect(Object.values((await getPerformanceSalaryDetails('reader', '2026-09')).roles).flat()).toEqual([])
})
test('最新权重、岗位改名及转岗对历史月份生效,多个方案保持独立', async () => {
const jobs = positions()
jobs[1].name = '编导策划'; jobs[1].revision = 2
jobs[1].dimensions[0].weight = '100'; jobs[1].dimensions[1].weight = '0'; jobs[1].dimensions[2].weight = '0'
jobs[1].salaryRole = 'ai-technical'
db.salaryPositionConfig.findMany.mockResolvedValue(jobs)
const data = await getPerformanceSalaryDetails('reader', '2025-01')
expect(data.roles['ai-planning']).toEqual([])
expect(data.roles['ai-technical'][0].totalScore).toBe(90)
expect(data.positionGroups[1].template.title).toBe('编导策划')
expect(data.positionGroups).toHaveLength(3)
expect(workflow).toHaveBeenLastCalledWith('2025-01', expect.any(Array))
})
test('正权重缺失阻断总分;空配置仍列出基础档案', async () => {
db.performanceSurveyResponse.findMany.mockResolvedValue([])
expect((await getPerformanceSalaryDetails('reader', '2026-09')).roles['ai-planning'][0]).toMatchObject({ totalScore: null, values: { performanceScore: null, performanceCoefficient: null, currentTotal: null } })
const jobs = positions(); jobs[1].dimensions = []
db.salaryPositionConfig.findMany.mockResolvedValue(jobs)
expect((await getPerformanceSalaryDetails('reader', '2026-09')).roles['ai-planning'][0]).toMatchObject({ totalScore: null, metrics: {}, values: { baseSalary: '100.01', performanceCoefficient: null, currentTotal: null } })
})
test('原始零分正常保留,零权重缺失不阻断,贡献与总分不重复加权', async () => {
db.performanceSurveyResponse.findMany.mockResolvedValue([response('p1', 'visual_brand_tone', 0), response('p1', 'work_cooperation', 60), response('p1', 'project_result_validation', 100)])
workflow.mockResolvedValue({ sourceMonth: '2026-10', points: new Map([['p1', 71]]), onTimeRates: new Map([['p1', 100]]) })
const data = await getPerformanceSalaryDetails('reader', '2026-10')
const row = data.roles['ai-planning'][0]
const dimensions = data.positionGroups[1].position.dimensions
expect(row.values[`${dimensions[0].metrics[0].id}RawValue`]).toBe(0)
expect(row.values[`${dimensions[0].metrics[0].id}Score`]).toBe(0)
expect(row.values[`${dimensions[0].metrics[1].id}RawValue`]).toBeNull()
expect(row.values[`${dimensions[0].metrics[1].id}Score`]).toBeNull()
expect(row.values[`${dimensions[1].metrics[1].id}RawValue`]).toBe(100)
expect(row.values[`${dimensions[1].metrics[1].id}Score`]).toBe(63)
expect(row.totalScore).toBe(73)
expect(row.values).toMatchObject({ performanceCoefficient: .73, currentTotal: '141.91' })
})
test.each(['ai-planning', 'photography', 'spatial-visual', 'management', 'ai-technical'])('%s统一按表中贡献之和、两位系数计算当月薪资', async salaryRole => {
const jobs = positions(); jobs[1].salaryRole = salaryRole
if (salaryRole === 'management') jobs[1].dimensions[1].metrics[0].source = { kind: 'survey', templateCode: 'project_result_validation' }
db.salaryPositionConfig.findMany.mockResolvedValue(jobs)
db.performanceSurveyResponse.findMany.mockResolvedValue([response('p1', 'visual_brand_tone', 88.885), response('p1', 'work_cooperation', 88.885), response('p1', 'project_result_validation', 88.885)])
workflow.mockResolvedValue({ sourceMonth: '2026-09', points: new Map([['p1', 71]]), deliveryCounts: new Map([['p1', { onTime: 88885, total: 100000 }]]), onTimeRates: new Map([['p1', 88.885]]) })
;(readSalaryMarketIntent as jest.Mock).mockResolvedValue(new Map([['p1', { rawScore: 88.885, selected: [] }]]))
const data = await getPerformanceSalaryDetails('reader', '2026-09')
const row = Object.values(data.roles).flat()[0]
expect(row).toMatchObject({ totalScore: 88.88, values: { performanceScore: 88.88, performanceCoefficient: .89, currentTotal: '146.71' } })
expect(db.personnelSalaryBase.findMany).toHaveBeenCalledWith(expect.objectContaining({ where: { deletedAt: null } }))
expect(row.values.previousTotal).toBeUndefined()
expect(data.positionGroups[1].template.columns.filter(c => c.key === 'performanceCoefficient')).toHaveLength(1)
})
test('本地调研回退不造成市场月份二次前移,生产和有提交时禁止回退', async () => {
process.env.PERFORMANCE_SALARY_LOCAL_TEST_FALLBACK = 'true'
expect((await getPerformanceSalaryDetails('reader', '2026-10')).sourceMonth).toBe('2026-09')
expect(workflow).toHaveBeenLastCalledWith('2026-09', expect.any(Array))
expect(readSalaryMarketIntent).toHaveBeenLastCalledWith('2026-09', expect.any(Array), ['p1'])
db.performanceSurveyResponse.count.mockResolvedValue(1)
expect((await getPerformanceSalaryDetails('reader', '2026-10')).isFallback).toBe(false)
Object.assign(process.env, { NODE_ENV: 'production' }); db.performanceSurveyResponse.count.mockResolvedValue(0)
expect((await getPerformanceSalaryDetails('reader', '2026-10')).isFallback).toBe(false)
})
test('权限失败不读取业务数据', async () => {
;(requireSalaryAccess as jest.Mock).mockRejectedValue(new Error('denied'))
await expect(getPerformanceSalaryDetails('forged-admin', '2026-10')).rejects.toThrow('denied')
expect(db.$transaction).not.toHaveBeenCalled()
expect(readSalaryMarketIntent).not.toHaveBeenCalled()
})
test('市场验证原始分由环比映射,按7%计分;没有经营数据不回退调研分', async () => {
;(readSalaryMarketIntent as jest.Mock).mockResolvedValue(new Map([['p1', { rawScore: 108.74, averageChange: .0874, validCount: 2, selected: [] }]]))
const data = await getPerformanceSalaryDetails('reader', '2026-09'), row = data.roles['ai-planning'][0]
const metric = data.positionGroups[1].position.dimensions[1].metrics[0]
expect(row.metrics[metric.id]).toBe(108.74)
expect(row.values[`${metric.id}RawValue`]).toBe(108.74)
expect(row.values[`${metric.id}Score`]).toBe(7.61)
expect(row.totalScore).toBe(89.81)
expect(row.metricEvidence?.[metric.id]).toMatchObject({ averageChange: .0874 })
;(readSalaryMarketIntent as jest.Mock).mockResolvedValue(new Map())
expect((await getPerformanceSalaryDetails('reader', '2026-09')).roles['ai-planning'][0].totalScore).toBeNull()
})
// Month selection belongs to the aggregation layer; the conversion service receives the actual completed month.
test.each([['2026-10', '2026-09'], ['2026-09', '2026-08'], ['2027-01', '2026-12']])('%s仅市场验证取%s完结流程,其余来源及基础工资保持当月', async (month, previous) => {
;(readSalaryMarketIntent as jest.Mock).mockImplementation(async sourceMonth => new Map([['p1', { month: sourceMonth, rawScore: 120, selected: [], validCount: 1 }]]))
const data = await getPerformanceSalaryDetails('reader', month), row = data.roles['ai-planning'][0]
const dimensions = data.positionGroups[1].position.dimensions, marketMetric = dimensions[1].metrics[0]
expect(data).toMatchObject({ displayMonth: month, sourceMonth: month, marketSourceMonth: previous, isFallback: false })
expect(readSalaryMarketIntent).toHaveBeenCalledTimes(1)
expect(readSalaryMarketIntent).toHaveBeenCalledWith(previous, expect.any(Array), ['p1'])
expect(workflow).toHaveBeenCalledWith(month, expect.any(Array))
expect(db.performanceSurveyResponse.findMany.mock.calls[0][0].where.survey.assessmentMonth).toBe(month)
expect(row.metricEvidence?.[marketMetric.id]).toMatchObject({ month: previous })
expect(row.values).toMatchObject({ points: 71, baseSalary: '100.01', gradeSalary: '20.00', performanceSalary: '30.00', performanceCoefficient: .91, currentTotal: '147.31' })
expect(row.totalScore).toBe(90.6)
expect(row.values[`${marketMetric.id}Score`]).toBe(8.4)
expect(row.values[`${dimensions[1].metrics[1].id}RawValue`]).toBe(90)
})
test('上月来源失败不返回部分得分,也不读取更早月份兜底', async () => {
;(readSalaryMarketIntent as jest.Mock).mockRejectedValue(Object.assign(new Error('经营数据暂不可用'), { status: 503 }))
await expect(getPerformanceSalaryDetails('reader', '2026-10')).rejects.toMatchObject({ status: 503 })
expect(readSalaryMarketIntent).toHaveBeenCalledTimes(1)
expect(readSalaryMarketIntent).toHaveBeenCalledWith('2026-09', expect.any(Array), ['p1'])
})
test('姓名或花名冲突时调研留空并列入核对清单,积分、交付率及工资基础值不变', async () => {
db.performanceSurveyEmployeeProfile.findMany.mockResolvedValue([{ id: 'p1', realName: '档案名字' }, { id: 'other', flowerName: '档案花名' }])
const data = await getPerformanceSalaryDetails('reader', '2026-10')
const row = data.roles['ai-planning'][0], dimensions = data.positionGroups[1].position.dimensions
expect(data.surveyMatchIssues).toEqual([{ employeeProfileId: 'p1', employeeLabel: '档案花名', salaryRole: 'ai-planning', reason: 'name-conflict', message: '姓名和花名对应不同人员' }])
expect(row.values[`${dimensions[0].metrics[0].id}RawValue`]).toBeNull()
expect(row.values[`${dimensions[1].metrics[1].id}RawValue`]).toBe(90)
expect(row.values).toMatchObject({ points: 71, baseSalary: '100.01', performanceCoefficient: null, currentTotal: null })
})
test('主管终评102先按正式规则汇总,自评103及其他人员109不混入;无同人记录保持缺失', async () => {
const jobs = positions(); db.salaryPositionConfig.findMany.mockResolvedValue(jobs)
const base = (await db.personnelSalaryBase.findMany())[0]; base.positionId = 'job0'
db.personnelSalaryBase.findMany.mockResolvedValue([base])
const code = 'supervisor-visual'; jobs[0].dimensions[0].metrics[0].source = { kind: 'survey', templateCode: code }
jobs[0].dimensions[0].weight = '50'
const official = (id: string, score: number, stage: string) => ({ ...response(id, code, score), assignment: { workflowStageKey: stage, reviewerSource: stage === 'self_review' ? 'self' : 'fixed_employee' }, survey: { templateCode: code, templateSnapshot: { code, questions: [], workflow: { scoring: { mode: 'final_reviewer', stageKey: 'final_review', reviewerSource: 'fixed_employee' } } } } })
db.performanceSurveyResponse.findMany.mockResolvedValue([official('p1', 103, 'self_review'), official('p1', 102, 'final_review'), official('other', 109, 'final_review')])
let data = await getPerformanceSalaryDetails('reader', '2026-08')
const metric = jobs[0].dimensions[0].metrics[0]
expect(data.roles.management[0].values[`${metric.id}RawValue`]).toBe(102)
expect(data.roles.management[0].values[`${metric.id}Score`]).toBe(40.8)
db.performanceSurveyResponse.findMany.mockResolvedValue([official('other', 109, 'final_review')])
data = await getPerformanceSalaryDetails('reader', '2026-09')
expect(data.roles.management[0].values[`${metric.id}RawValue`]).toBeNull()
expect(data.surveyMatchIssues).toEqual([])
})
test('主管两项使用主部门汇总;批量读取包含未匹配职级的策划成员,其他部门隔离', async () => {
const jobs = positions()
jobs[0].dimensions[0].weight = '50'; jobs[0].dimensions[1].weight = '40'
jobs[0].dimensions[1].metrics[0].source = { kind: 'market-intent-top3' }
jobs[0].dimensions[1].metrics[1].weight = '30'; jobs[0].dimensions[1].metrics[2].weight = '30'
jobs[1].dimensions = []
db.salaryPositionConfig.findMany.mockResolvedValue(jobs)
const supervisor = { ...(await db.personnelSalaryBase.findMany())[0], id: 'manager-base', positionId: 'job0' }
db.personnelSalaryBase.findMany.mockResolvedValue([supervisor, ...['p2', 'p3', 'other'].map(id => ({ ...supervisor, id: `base-${id}`, employeeProfileId: id, name: id, flowerName: id, positionId: 'job1', jobGrade: '' }))])
db.performanceSurveyEmployeeProfile.findMany.mockResolvedValue([
{ id: 'p1', realName: '档案名字', flowerName: '档案花名', displayName: 'p1', employmentState: 'ACTIVE', departmentPath: '公司/配置部门' },
...['p2', 'p3', 'video'].map(id => ({ id, displayName: id, realName: id, employmentState: 'ACTIVE', departmentPath: '公司/配置部门' })),
{ id: 'other', displayName: 'other', employmentState: 'ACTIVE', departmentPath: '公司/其他部门' },
])
db.organizationUnit.findMany.mockResolvedValue([{ sourceDeptId: 1, name: '配置部门', path: '公司/配置部门' }, { sourceDeptId: 2, name: '其他部门', path: '公司/其他部门' }])
workflow.mockResolvedValue({ sourceMonth: '2026-10', points: new Map([['p1', 71]]), onTimeRates: new Map([['p1', 100]]), deliveryCounts: new Map([['p1', { onTime: 1, total: 1 }], ['p2', { onTime: 5, total: 10 }], ['other', { onTime: 0, total: 10 }]]) })
const candidate = (key: string, change: number): MarketIntentCandidate => ({ key, workflowId: key, approvalNumber: key, productId: '123456', brand: '测试', completedAt: '2026-09-01T00:00:00Z', invalidReason: null, intentRateChange: change, sevenDayIntentRate: .1, fifteenDayIntentRate: .1 * (1 + change) })
;(readSalaryMarketIntent as jest.Mock).mockResolvedValue(new Map([['p2', summarizeMarketIntent('2026-09', [candidate('shared', .12), candidate('a', .10)])], ['p3', summarizeMarketIntent('2026-09', [candidate('shared', .12), candidate('b', .11)])]]))
const data = await getPerformanceSalaryDetails('reader', '2026-10'), row = data.roles.management[0]
const marketId = jobs[0].dimensions[1].metrics[0].id, deliveryId = jobs[0].dimensions[1].metrics[1].id
expect(readSalaryMarketIntent).toHaveBeenCalledTimes(1)
expect(new Set((readSalaryMarketIntent as jest.Mock).mock.calls[0][2])).toEqual(new Set(['p2', 'p3']))
expect(row.values[`${marketId}RawValue`]).toBe(111)
expect(row.values[`${marketId}Score`]).toBe(17.76)
expect(row.values[`${deliveryId}RawValue`]).toBe(75)
expect(row.values[`${deliveryId}Score`]).toBe(9)
expect(row.metricEvidence?.[marketId]).toMatchObject({ month: '2026-09', candidateCount: 3, departmentScope: { members: expect.any(Array) } })
expect(row.metricEvidence?.[deliveryId]).toMatchObject({ month: '2026-10', includedCount: 2, members: expect.arrayContaining([expect.objectContaining({ employeeProfileId: 'video', included: false })]) })
expect(data.roles['ai-planning'].every(p => p.performanceMatch === 'unmatched')).toBe(true)
expect(data.departmentMatchIssues).toEqual([])
})
test('主管组织归属不明时部门指标留空并提示,不能使用薪资部门文本或个人交付率代替', async () => {
const jobs = positions(), base = { ...(await db.personnelSalaryBase.findMany())[0], positionId: 'job0' }
db.salaryPositionConfig.findMany.mockResolvedValue(jobs); db.personnelSalaryBase.findMany.mockResolvedValue([base])
db.performanceSurveyEmployeeProfile.findMany.mockResolvedValue([{ id: 'p1', realName: '档案名字', flowerName: '档案花名', displayName: 'p1', employmentState: 'ACTIVE' }])
const data = await getPerformanceSalaryDetails('reader', '2026-10')
expect(data.roles.management[0].values[`${jobs[0].dimensions[1].metrics[1].id}RawValue`]).toBeNull()
expect(data.departmentMatchIssues).toEqual([expect.objectContaining({ employeeProfileId: 'p1', message: expect.stringContaining('主部门') })])
})