@steedos-labs/content-compliance 0.8.8 → 0.8.10

package/lib/methods/__tests__/plsReview.test.js

@@ -0,0 +1,736 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var pls_1 = require("../pls");
+describe('PLS review adoption permission', function () {
+    it('allows adoption only for a pending user in a review step', function () {
+        expect((0, pls_1.canAdoptReview)({
+            current_step: 'departmental_review',
+            person_pending_approve: ['reviewer-1']
+        }, 'reviewer-1')).toBe(true);
+        expect((0, pls_1.canAdoptReview)({
+            current_step: 'personnel_review',
+            person_pending_approve: ['reviewer-1']
+        }, 'reviewer-1')).toBe(true);
+        expect((0, pls_1.canAdoptReview)({
+            current_step: 'departmental_review',
+            person_pending_approve: ['reviewer-2']
+        }, 'reviewer-1')).toBe(false);
+        expect((0, pls_1.canAdoptReview)({
+            current_step: 'conclusion',
+            person_pending_approve: ['reviewer-1']
+        }, 'reviewer-1')).toBe(false);
+        expect((0, pls_1.canAdoptReview)(null, 'reviewer-1')).toBe(false);
+    });
+    it.each(['awaiting_deployment', 'conclusion'])('allows a spot-check operator to adopt in %s', function (currentStep) {
+        expect((0, pls_1.canAdoptReview)({
+            current_step: currentStep,
+            person_pending_approve: []
+        }, 'spot-checker-1', ['user', 'pepsico_spot_check'])).toBe(true);
+    });
+    it('does not let spot-check permission bypass reviewer-node assignment', function () {
+        expect((0, pls_1.canAdoptReview)({
+            current_step: 'departmental_review',
+            person_pending_approve: ['reviewer-2']
+        }, 'spot-checker-1', ['pepsico_spot_check'])).toBe(false);
+    });
+    it('denies post-review adoption without the spot-check permission set', function () {
+        expect((0, pls_1.canAdoptReview)({
+            current_step: 'conclusion',
+            person_pending_approve: ['viewer-1']
+        }, 'viewer-1', ['user'])).toBe(false);
+    });
+    it('denies adoption in unrelated states even with the spot-check permission set', function () {
+        expect((0, pls_1.canAdoptReview)({
+            current_step: 'draft',
+            person_pending_approve: []
+        }, 'spot-checker-1', ['pepsico_spot_check'])).toBe(false);
+    });
+    it('returns material adoption permission from its approval', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var ctx;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ctx = {
+                        meta: { user: { userId: 'reviewer-1' } },
+                        getObject: function (name) {
+                            if (name === 'pepsico_material') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        pepsico_material_approval: 'approval-1'
+                                    })
+                                };
+                            }
+                            if (name === 'pepsico_material_approval') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        current_step: 'departmental_review',
+                                        person_pending_approve: ['reviewer-1'],
+                                        pls_km_files: ['pls-1']
+                                    })
+                                };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, expect((0, pls_1.getMaterialReviewPermissions)(ctx, 'material-1'))
+                            .resolves.toEqual({ canAdopt: true, hasPLSFile: true })];
+                case 1:
+                    _a.sent();
+                    return [2];
+            }
+        });
+    }); });
+    it('returns material adoption permission for a spot-check operator after review', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var ctx;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ctx = {
+                        meta: {
+                            user: {
+                                userId: 'spot-checker-1',
+                                roles: ['user', 'pepsico_spot_check']
+                            }
+                        },
+                        getObject: function (name) {
+                            if (name === 'pepsico_material') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        pepsico_material_approval: 'approval-1'
+                                    })
+                                };
+                            }
+                            if (name === 'pepsico_material_approval') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        current_step: 'awaiting_deployment',
+                                        person_pending_approve: [],
+                                        pls_km_files: ['pls-1']
+                                    })
+                                };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, expect((0, pls_1.getMaterialReviewPermissions)(ctx, 'material-1'))
+                            .resolves.toEqual({ canAdopt: true, hasPLSFile: true })];
+                case 1:
+                    _a.sent();
+                    return [2];
+            }
+        });
+    }); });
+    it('fails closed when the approval or current user is missing', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var buildCtx;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    buildCtx = function (approval, userId) { return ({
+                        meta: { user: userId ? { userId: userId } : undefined },
+                        getObject: function (name) {
+                            if (name === 'pepsico_material') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        pepsico_material_approval: 'approval-1'
+                                    })
+                                };
+                            }
+                            if (name === 'pepsico_material_approval') {
+                                return { findOne: jest.fn().mockResolvedValue(approval) };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    }); };
+                    return [4, expect((0, pls_1.getMaterialReviewPermissions)(buildCtx(null, 'reviewer-1'), 'material-1'))
+                            .resolves.toEqual({ canAdopt: false, hasPLSFile: false })];
+                case 1:
+                    _a.sent();
+                    return [4, expect((0, pls_1.getMaterialReviewPermissions)(buildCtx({
+                            current_step: 'departmental_review',
+                            person_pending_approve: ['reviewer-1']
+                        }), 'material-1')).resolves.toEqual({ canAdopt: false, hasPLSFile: false })];
+                case 2:
+                    _a.sent();
+                    return [2];
+            }
+        });
+    }); });
+    it.each([
+        ['empty array', []],
+        ['null', null],
+        ['missing field', undefined],
+        ['empty values', [null, '']]
+    ])('treats %s PLS lookup values as empty', function (_label, plsKmFiles) { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var ctx;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ctx = {
+                        meta: { user: { userId: 'viewer-1' } },
+                        getObject: function (name) {
+                            if (name === 'pepsico_material') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        pepsico_material_approval: 'approval-1'
+                                    })
+                                };
+                            }
+                            if (name === 'pepsico_material_approval') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        pls_km_files: plsKmFiles
+                                    })
+                                };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, expect((0, pls_1.getMaterialReviewPermissions)(ctx, 'material-1'))
+                            .resolves.toEqual({ canAdopt: false, hasPLSFile: false })];
+                case 1:
+                    _a.sent();
+                    return [2];
+            }
+        });
+    }); });
+});
+describe('PLS change log', function () {
+    var buildCtx = function (changeLogInsert) { return ({
+        meta: { user: { userId: 'sra-1' } },
+        getObject: function (name) {
+            if (name === 'pepsico_km_pls_file') {
+                return {
+                    directFind: jest.fn().mockResolvedValue([
+                        { _id: 'pls-a', name: 'PLS 旧版' },
+                        { _id: 'pls-d', name: 'PLS 新版' }
+                    ])
+                };
+            }
+            if (name === 'pepsico_pls_change_log') {
+                return { directInsert: changeLogInsert };
+            }
+            throw new Error("Unexpected object ".concat(name));
+        }
+    }); };
+    it('records the change with redundant file names', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var changeLogInsert;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    changeLogInsert = jest.fn();
+                    return [4, (0, pls_1.logPLSChange)(buildCtx(changeLogInsert), {
+                            approval: { _id: 'approval-1', name: 'AP-001', space: 'space-1' },
+                            scene: 'reviewer_change',
+                            materialId: 'material-1',
+                            beforeIds: ['pls-a'],
+                            afterIds: ['pls-d'],
+                            source: 'upload'
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(changeLogInsert).toHaveBeenCalledWith(expect.objectContaining({
+                        approval: 'approval-1',
+                        approval_name: 'AP-001',
+                        material: 'material-1',
+                        scene: 'reviewer_change',
+                        source: 'upload',
+                        before_pls_files: ['pls-a'],
+                        before_pls_names: 'PLS 旧版',
+                        after_pls_files: ['pls-d'],
+                        after_pls_names: 'PLS 新版',
+                        operator: 'sra-1',
+                        space: 'space-1'
+                    }));
+                    return [2];
+            }
+        });
+    }); });
+    it('skips approvals that never had a PLS file', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var changeLogInsert;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    changeLogInsert = jest.fn();
+                    return [4, (0, pls_1.logPLSChange)(buildCtx(changeLogInsert), {
+                            approval: { _id: 'approval-1' },
+                            scene: 'submit',
+                            beforeIds: [],
+                            afterIds: []
+                        })];
+                case 1:
+                    _a.sent();
+                    expect(changeLogInsert).not.toHaveBeenCalled();
+                    return [2];
+            }
+        });
+    }); });
+    it('never throws when the log write fails', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var ctx;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ctx = {
+                        meta: { user: { userId: 'sra-1' } },
+                        getObject: function () { throw new Error('boom'); }
+                    };
+                    return [4, expect((0, pls_1.logPLSChange)(ctx, {
+                            approval: { _id: 'approval-1' },
+                            scene: 'submit',
+                            beforeIds: ['pls-a'],
+                            afterIds: ['pls-a']
+                        })).resolves.toBeUndefined()];
+                case 1:
+                    _a.sent();
+                    return [2];
+            }
+        });
+    }); });
+});
+describe('PLS review source management', function () {
+    it('backfills the approval on the PLS record without touching pls_km_files', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var plsUpdate, approvalUpdate, ctx, result;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    plsUpdate = jest.fn();
+                    approvalUpdate = jest.fn();
+                    ctx = {
+                        meta: { user: { userId: 'sra-1', spaceId: 'space-1' } },
+                        getObject: function (name) {
+                            if (name === 'cfs_files_filerecord') {
+                                return {
+                                    directFind: jest.fn().mockResolvedValue([
+                                        { _id: 'file-1', original: { name: 'PLS新规.pdf', type: 'application/pdf' } }
+                                    ])
+                                };
+                            }
+                            if (name === 'pepsico_km_pls_file') {
+                                return {
+                                    directInsert: jest.fn().mockResolvedValue({ _id: 'pls-new', name: 'PLS新规' }),
+                                    directUpdate: plsUpdate
+                                };
+                            }
+                            if (name === 'pepsico_material_approval') {
+                                return { directUpdate: approvalUpdate };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, (0, pls_1.createApplicationPLSFiles)(ctx, ['file-1'], {
+                            _id: 'approval-1',
+                            pls_km_files: ['pls-a']
+                        })];
+                case 1:
+                    result = _a.sent();
+                    expect(result.records).toEqual([{ id: 'pls-new', name: 'PLS新规' }]);
+                    expect(plsUpdate).toHaveBeenCalledWith('pls-new', expect.objectContaining({
+                        pepsico_material_approval: 'approval-1'
+                    }));
+                    expect(approvalUpdate).not.toHaveBeenCalled();
+                    return [2];
+            }
+        });
+    }); });
+    it('shows PLS opinions with true, null, or missing active status', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var reviews, ctx, result;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    reviews = [
+                        { _id: 'review-true', pls_file: 'pls-a', is_active: true },
+                        { _id: 'review-false', pls_file: 'pls-a', is_active: false },
+                        { _id: 'review-null', pls_file: 'pls-a', is_active: null },
+                        { _id: 'review-missing', pls_file: 'pls-a' }
+                    ];
+                    ctx = {
+                        meta: { user: { userId: 'viewer-1' } },
+                        getObject: function (name) {
+                            if (name === 'pepsico_material') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        _id: 'material-1',
+                                        pepsico_material_approval: 'approval-1'
+                                    })
+                                };
+                            }
+                            if (name === 'pepsico_material_approval') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        _id: 'approval-1',
+                                        current_step: 'departmental_review',
+                                        person_pending_approve: ['viewer-1']
+                                    })
+                                };
+                            }
+                            if (name === 'pepsico_ai_review') {
+                                return { find: jest.fn().mockResolvedValue(reviews) };
+                            }
+                            if (name === 'pepsico_km_pls_file') {
+                                return {
+                                    directFind: jest.fn().mockResolvedValue([
+                                        { _id: 'pls-a', name: 'PLS-Lay's & More', is_active: true }
+                                    ])
+                                };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, (0, pls_1.getPLSReviewGroups)(ctx, 'material-1')];
+                case 1:
+                    result = _a.sent();
+                    expect(result.groups).toHaveLength(1);
+                    expect(result.groups[0].reviews.map(function (review) { return review._id; })).toEqual([
+                        'review-true',
+                        'review-null',
+                        'review-missing'
+                    ]);
+                    expect(result.groups[0].plsName).toBe("PLS-Lay's & More");
+                    expect(result.canAdopt).toBe(true);
+                    expect(result.groups[0].canAdopt).toBe(true);
+                    return [2];
+            }
+        });
+    }); });
+    it('returns adoptable PLS groups for a spot-check operator after review', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var ctx, result;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ctx = {
+                        meta: {
+                            user: {
+                                userId: 'spot-checker-1',
+                                roles: ['user', 'pepsico_spot_check']
+                            }
+                        },
+                        getObject: function (name) {
+                            if (name === 'pepsico_material') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        _id: 'material-1',
+                                        pepsico_material_approval: 'approval-1'
+                                    })
+                                };
+                            }
+                            if (name === 'pepsico_material_approval') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        _id: 'approval-1',
+                                        current_step: 'conclusion',
+                                        person_pending_approve: []
+                                    })
+                                };
+                            }
+                            if (name === 'pepsico_ai_review') {
+                                return {
+                                    find: jest.fn().mockResolvedValue([
+                                        { _id: 'review-1', pls_file: 'pls-a', is_active: true }
+                                    ])
+                                };
+                            }
+                            if (name === 'pepsico_km_pls_file') {
+                                return {
+                                    directFind: jest.fn().mockResolvedValue([
+                                        { _id: 'pls-a', name: 'PLS A', is_active: true }
+                                    ])
+                                };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, (0, pls_1.getPLSReviewGroups)(ctx, 'material-1')];
+                case 1:
+                    result = _a.sent();
+                    expect(result.canAdopt).toBe(true);
+                    expect(result.groups[0].canAdopt).toBe(true);
+                    return [2];
+            }
+        });
+    }); });
+    it('returns review groups with adoption disabled when the approval is missing', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var ctx;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ctx = {
+                        meta: { user: { userId: 'viewer-1' } },
+                        getObject: function (name) {
+                            if (name === 'pepsico_material') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        _id: 'material-1',
+                                        pepsico_material_approval: 'approval-missing'
+                                    })
+                                };
+                            }
+                            if (name === 'pepsico_material_approval') {
+                                return { findOne: jest.fn().mockResolvedValue(null) };
+                            }
+                            if (name === 'pepsico_ai_review') {
+                                return {
+                                    find: jest.fn().mockResolvedValue([
+                                        { _id: 'review-1', pls_file: 'pls-a', is_active: true }
+                                    ])
+                                };
+                            }
+                            if (name === 'pepsico_km_pls_file') {
+                                return {
+                                    directFind: jest.fn().mockResolvedValue([
+                                        { _id: 'pls-a', name: 'PLS A', is_active: true }
+                                    ])
+                                };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, expect((0, pls_1.getPLSReviewGroups)(ctx, 'material-1')).resolves.toMatchObject({
+                            canManage: false,
+                            canAdopt: false,
+                            groups: [{
+                                    approvalId: 'approval-missing',
+                                    canManage: false,
+                                    canAdopt: false
+                                }]
+                        })];
+                case 1:
+                    _a.sent();
+                    return [2];
+            }
+        });
+    }); });
+    it('offers PLS files with true, null, or missing active status', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var ctx, options;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ctx = {
+                        getObject: function (name) {
+                            if (name === 'pepsico_km_pls_file') {
+                                return {
+                                    find: jest.fn().mockResolvedValue([
+                                        { _id: 'pls-true', name: 'PLS-Lay's & More', is_active: true },
+                                        { _id: 'pls-false', name: 'False', is_active: false },
+                                        { _id: 'pls-null', name: 'Null', is_active: null },
+                                        { _id: 'pls-missing', name: 'Missing' }
+                                    ])
+                                };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, (0, pls_1.getActivePLSOptions)(ctx)];
+                case 1:
+                    options = _a.sent();
+                    expect(options.map(function (option) { return option.value; })).toEqual([
+                        'pls-true',
+                        'pls-null',
+                        'pls-missing'
+                    ]);
+                    expect(options[0].label).toBe("PLS-Lay's & More");
+                    return [2];
+            }
+        });
+    }); });
+    it('invalidates PLS opinions unless they are explicitly inactive', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var reviewUpdate, ctx, invalidated;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    reviewUpdate = jest.fn();
+                    ctx = {
+                        getObject: function (name) {
+                            if (name === 'pepsico_ai_review') {
+                                return {
+                                    directFind: jest.fn().mockResolvedValue([
+                                        { _id: 'review-true', is_active: true },
+                                        { _id: 'review-false', is_active: false },
+                                        { _id: 'review-null', is_active: null },
+                                        { _id: 'review-missing' }
+                                    ]),
+                                    directUpdateMany: reviewUpdate
+                                };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, (0, pls_1.invalidatePLSReviews)(ctx, 'approval-1')];
+                case 1:
+                    invalidated = _a.sent();
+                    expect(invalidated).toBe(3);
+                    expect(reviewUpdate).toHaveBeenCalledWith(['_id', 'in', ['review-true', 'review-null', 'review-missing']], expect.objectContaining({ is_active: false }));
+                    return [2];
+            }
+        });
+    }); });
+    it('recognizes users from the current reviewer configuration', function () {
+        var approval = {
+            sra_reviewer: ['sra-1'],
+            qc_reviewer: ['qc-1'],
+            reviewer: ['fixed-1']
+        };
+        expect((0, pls_1.isApprovalReviewer)(approval, 'sra-1')).toBe(true);
+        expect((0, pls_1.isApprovalReviewer)(approval, 'qc-1')).toBe(true);
+        expect((0, pls_1.isApprovalReviewer)(approval, 'owner-1')).toBe(false);
+    });
+    it('limits invalidation to one material when a material is given', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var reviewFind, ctx;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    reviewFind = jest.fn().mockResolvedValue([]);
+                    ctx = {
+                        getObject: function (name) {
+                            if (name === 'pepsico_ai_review') {
+                                return { directFind: reviewFind, directUpdateMany: jest.fn() };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, (0, pls_1.invalidatePLSReviews)(ctx, 'approval-1', 'pls-a', 'material-1')];
+                case 1:
+                    _a.sent();
+                    expect(reviewFind).toHaveBeenCalledWith(expect.objectContaining({
+                        filters: [
+                            ['pepsico_material_approval', '=', 'approval-1'],
+                            ['review_type', '=', 'pls'],
+                            ['pls_file', '=', 'pls-a'],
+                            ['pepsico_material', '=', 'material-1']
+                        ]
+                    }));
+                    return [2];
+            }
+        });
+    }); });
+    it('replaces only the selected PLS source and invalidates its old opinions', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var approval, approvalUpdate, reviewUpdate, reviewFind, changeLogInsert, ctx, result;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    approval = {
+                        _id: 'approval-1',
+                        sra_reviewer: ['sra-1'],
+                        pls_km_files: ['pls-a', 'pls-b', 'pls-c']
+                    };
+                    approvalUpdate = jest.fn();
+                    reviewUpdate = jest.fn();
+                    reviewFind = jest.fn().mockResolvedValue([{ _id: 'review-a' }]);
+                    changeLogInsert = jest.fn();
+                    ctx = {
+                        meta: { user: { userId: 'sra-1' } },
+                        getObject: function (name) {
+                            if (name === 'pepsico_material_approval') {
+                                return { findOne: jest.fn().mockResolvedValue(approval), directUpdate: approvalUpdate };
+                            }
+                            if (name === 'pepsico_km_pls_file') {
+                                return { directFind: jest.fn().mockResolvedValue([{ _id: 'pls-d' }]) };
+                            }
+                            if (name === 'pepsico_ai_review') {
+                                return {
+                                    directFind: reviewFind,
+                                    directUpdateMany: reviewUpdate
+                                };
+                            }
+                            if (name === 'pepsico_pls_change_log') {
+                                return { directInsert: changeLogInsert };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, (0, pls_1.replaceApprovalPLSSource)(ctx, 'approval-1', 'pls-a', 'pls-d', 'material-1', 'existing')];
+                case 1:
+                    result = _a.sent();
+                    expect(result.pls_km_files).toEqual(['pls-d', 'pls-b', 'pls-c']);
+                    expect(approvalUpdate).toHaveBeenCalledWith('approval-1', expect.objectContaining({
+                        pls_km_files: ['pls-d', 'pls-b', 'pls-c']
+                    }));
+                    expect(reviewUpdate).toHaveBeenCalledWith(['_id', 'in', ['review-a']], expect.objectContaining({ is_active: false }));
+                    expect(reviewFind).toHaveBeenCalledWith(expect.objectContaining({
+                        filters: expect.arrayContaining([['pepsico_material', '=', 'material-1']])
+                    }));
+                    expect(changeLogInsert).toHaveBeenCalledWith(expect.objectContaining({
+                        scene: 'reviewer_change',
+                        material: 'material-1',
+                        source: 'existing',
+                        before_pls_files: ['pls-a'],
+                        after_pls_files: ['pls-d']
+                    }));
+                    return [2];
+            }
+        });
+    }); });
+    it('accepts replacement sources that are not active yet', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var approvalUpdate, ctx, result;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    approvalUpdate = jest.fn();
+                    ctx = {
+                        meta: { user: { userId: 'qc-1' } },
+                        getObject: function (name) {
+                            if (name === 'pepsico_material_approval') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        _id: 'approval-1',
+                                        qc_reviewer: ['qc-1'],
+                                        pls_km_files: ['pls-a']
+                                    }),
+                                    directUpdate: approvalUpdate
+                                };
+                            }
+                            if (name === 'pepsico_ai_review') {
+                                return {
+                                    directFind: jest.fn().mockResolvedValue([]),
+                                    directUpdateMany: jest.fn()
+                                };
+                            }
+                            if (name === 'pepsico_km_pls_file') {
+                                return { directFind: jest.fn().mockResolvedValue([]) };
+                            }
+                            if (name === 'pepsico_pls_change_log') {
+                                return { directInsert: jest.fn() };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, (0, pls_1.replaceApprovalPLSSource)(ctx, 'approval-1', 'pls-a', 'pls-inactive')];
+                case 1:
+                    result = _a.sent();
+                    expect(result.pls_km_files).toEqual(['pls-inactive']);
+                    expect(approvalUpdate).toHaveBeenCalledWith('approval-1', expect.objectContaining({
+                        pls_km_files: ['pls-inactive']
+                    }));
+                    return [2];
+            }
+        });
+    }); });
+    it('still rejects sources that are not linked to the approval', function () { return tslib_1.__awaiter(void 0, void 0, void 0, function () {
+        var ctx;
+        return tslib_1.__generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    ctx = {
+                        meta: { user: { userId: 'qc-1' } },
+                        getObject: function (name) {
+                            if (name === 'pepsico_material_approval') {
+                                return {
+                                    findOne: jest.fn().mockResolvedValue({
+                                        _id: 'approval-1',
+                                        qc_reviewer: ['qc-1'],
+                                        pls_km_files: ['pls-a']
+                                    })
+                                };
+                            }
+                            throw new Error("Unexpected object ".concat(name));
+                        }
+                    };
+                    return [4, expect((0, pls_1.replaceApprovalPLSSource)(ctx, 'approval-1', 'pls-unlinked', 'pls-new'))
+                            .rejects.toThrow('当前PLS来源未关联到审批单')];
+                case 1:
+                    _a.sent();
+                    return [2];
+            }
+        });
+    }); });
+});
+//# sourceMappingURL=plsReview.test.js.map