Harden integration read-only boundaries and admin contracts

This commit is contained in:
devops committed 2026-10-23 06:38:39 +00:00
1 parent ac065fa911
commit 841eab0556
21 files changed
+179 -687

No files matched your search

+23 -269
View File
@@ -1,271 +1,25 @@
import { Test, TestingModule } from "@nestjs/testing";
import { BadRequestException, NotFoundException } from "@nestjs/common";
import { ApprovalsController } from "./approvals.controller";
import { PrismaService } from "../prisma/prisma.service";
import { GoneException } from '@nestjs/common';
import { ApprovalsController } from './approvals.controller';
import { PrismaService } from '../prisma/prisma.service';
describe("ApprovalsController", () => {
let controller: ApprovalsController;
let prisma: {
approvalRequest: {
findUnique: jest.Mock;
findMany: jest.Mock;
count: jest.Mock;
create: jest.Mock;
update: jest.Mock;
delete: jest.Mock;
};
departmentTask: {
findFirst: jest.Mock;
findMany: jest.Mock;
create: jest.Mock;
update: jest.Mock;
deleteMany: jest.Mock;
updateMany: jest.Mock;
};
};
beforeEach(async () => {
prisma = {
approvalRequest: {
findUnique: jest.fn(),
findMany: jest.fn(),
count: jest.fn(),
create: jest.fn(),
update: jest.fn(),
delete: jest.fn(),
},
departmentTask: {
findFirst: jest.fn(),
findMany: jest.fn(),
create: jest.fn(),
update: jest.fn(),
deleteMany: jest.fn(),
updateMany: jest.fn(),
},
};
const module: TestingModule = await Test.createTestingModule({
controllers: [ApprovalsController],
providers: [
{
provide: PrismaService,
useValue: prisma,
},
],
}).compile();
controller = module.get<ApprovalsController>(ApprovalsController);
});
describe("decide - B2B_SUPPLIER_STRATEGY approval separation", () => {
it("B2B_SUPPLIER_STRATEGY approval must not create digital task nor set executedAt as physical action", async () => {
const approvalId = "b2b-strategy-uuid-1";
const approvalItem = {
id: approvalId,
department: "B2B",
category: "B2B_SUPPLIER_STRATEGY",
title: "[طرح استراتژیک تامین‌کننده] توسعه شبکه کلینیکی آلمان",
payload: { target: "German Suppliers", tier: "Direct" },
status: "PENDING",
};
prisma.approvalRequest.findUnique.mockResolvedValue(approvalItem);
prisma.approvalRequest.update.mockResolvedValue({
...approvalItem,
status: "APPROVED",
ceoNotes: "موافقت با مذاکره اولیه",
});
prisma.departmentTask.findFirst.mockResolvedValue(null);
const result = await controller.decide(approvalId, {
decision: "APPROVED",
ceoNotes: "موافقت با مذاکره اولیه",
});
expect(result.success).toBe(true);
expect(prisma.approvalRequest.update).toHaveBeenCalledWith({
where: { id: approvalId },
data: expect.objectContaining({
status: "APPROVED",
ceoNotes: "موافقت با مذاکره اولیه",
}),
});
// Verify executedAt is NOT set as physical action
const updateCall = prisma.approvalRequest.update.mock.calls[0][0];
expect(updateCall.data.executedAt).toBeUndefined();
// Verify NO digital task is created in departmentTask queue
expect(prisma.departmentTask.create).not.toHaveBeenCalled();
expect(prisma.departmentTask.update).not.toHaveBeenCalled();
});
it("B2B_SUPPLIER_STRATEGY approval must not requeue existing digital task", async () => {
const approvalId = "b2b-strategy-uuid-2";
const approvalItem = {
id: approvalId,
department: "B2B",
category: "B2B_SUPPLIER_STRATEGY",
title: "[طرح استراتژیک تامین‌کننده] پکیج نمونه دارویی",
payload: {},
status: "PENDING",
};
prisma.approvalRequest.findUnique.mockResolvedValue(approvalItem);
prisma.approvalRequest.update.mockResolvedValue({
...approvalItem,
status: "APPROVED",
});
prisma.departmentTask.findFirst.mockResolvedValue({
id: "task-existing-1",
status: "BACKLOG",
title: "Legacy task",
});
const result = await controller.decide(approvalId, {
decision: "APPROVED",
});
expect(result.success).toBe(true);
// Ensure existing task was NOT updated or requeued to TODO
expect(prisma.departmentTask.update).not.toHaveBeenCalled();
expect(prisma.departmentTask.create).not.toHaveBeenCalled();
});
});
describe("decide - SEO approval actionable digital task", () => {
it("SEO approval creates actionable digital task in TODO", async () => {
const approvalId = "seo-approval-uuid-1";
const approvalItem = {
id: approvalId,
department: "SEO",
category: "SEO",
title: "بهینه‌سازی متاتگ‌های صفحات دسته‌بندی گربه",
payload: { targetUrl: "/category/cat-food" },
status: "PENDING",
};
prisma.approvalRequest.findUnique.mockResolvedValue(approvalItem);
prisma.approvalRequest.update.mockResolvedValue({
...approvalItem,
status: "APPROVED",
ceoNotes: "در اولویت سئو قرار گیرد",
});
prisma.departmentTask.findFirst.mockResolvedValue(null);
prisma.departmentTask.create.mockResolvedValue({
id: "new-task-uuid",
code: "TSK-892110",
department: "SEO",
title: approvalItem.title,
status: "TODO",
priority: "HIGH",
assignee: "AI_AGENT",
approvalId: approvalId,
});
const result = await controller.decide(approvalId, {
decision: "APPROVED",
ceoNotes: "در اولویت سئو قرار گیرد",
});
expect(result.success).toBe(true);
expect(prisma.approvalRequest.update).toHaveBeenCalledWith({
where: { id: approvalId },
data: expect.objectContaining({
status: "APPROVED",
ceoNotes: "در اولویت سئو قرار گیرد",
}),
});
// Digital task MUST be created with status TODO
expect(prisma.departmentTask.create).toHaveBeenCalledWith({
data: expect.objectContaining({
department: "SEO",
title: approvalItem.title,
status: "TODO",
priority: "HIGH",
assignee: "AI_AGENT",
approvalId: approvalId,
}),
});
});
it("SEO approval requeues existing task to TODO when existing task found", async () => {
const approvalId = "seo-approval-uuid-2";
const approvalItem = {
id: approvalId,
department: "SEO",
category: "SEO",
title: "بررسی کنیبان سئو مقاله تغذیه سگ",
payload: {},
status: "PENDING",
};
const existingTask = {
id: "existing-task-99",
code: "TSK-112233",
status: "IN_REVIEW",
description: "Initial draft",
approvalId: approvalId,
};
prisma.approvalRequest.findUnique.mockResolvedValue(approvalItem);
prisma.approvalRequest.update.mockResolvedValue({
...approvalItem,
status: "APPROVED",
ceoNotes: "تایید نهایی جهت اقدام",
});
prisma.departmentTask.findFirst.mockResolvedValue(existingTask);
prisma.departmentTask.update.mockResolvedValue({
...existingTask,
status: "TODO",
});
const result = await controller.decide(approvalId, {
decision: "APPROVED",
ceoNotes: "تایید نهایی جهت اقدام",
});
expect(result.success).toBe(true);
expect(prisma.departmentTask.update).toHaveBeenCalledWith({
where: { id: existingTask.id },
data: expect.objectContaining({
status: "TODO",
}),
});
});
});
describe("decide - rejection handling", () => {
it("handles REJECTED decision cleanly without deleting approval audit history", async () => {
const approvalId = "approval-reject-uuid";
const approvalItem = {
id: approvalId,
department: "SEO",
category: "SEO",
title: "تغییر ساختار URL",
status: "PENDING",
};
prisma.approvalRequest.findUnique.mockResolvedValue(approvalItem);
prisma.approvalRequest.update.mockResolvedValue({
...approvalItem,
status: "REJECTED",
ceoNotes: "ریسک بالای افت رتبه سئو",
});
const result = await controller.decide(approvalId, {
decision: "REJECTED",
ceoNotes: "ریسک بالای افت رتبه سئو",
});
expect(result.success).toBe(true);
expect(prisma.approvalRequest.update).toHaveBeenCalledWith({
where: { id: approvalId },
data: expect.objectContaining({
status: "REJECTED",
ceoNotes: "ریسک بالای افت رتبه سئو",
}),
});
});
});
describe('ApprovalsController retired mutation boundary',()=>{
const access=jest.fn();
const prisma=new Proxy({},{get:(_target,key)=>{access(key);throw new Error('Database access forbidden');}});
const controller=new ApprovalsController(prisma as PrismaService);
beforeEach(()=>access.mockClear());
it('create {department:SEO,category:SEO,title:Legacy,payload:{}} returns 410 without reading or writing persistence',async()=>{
await expect(controller.create({department:'SEO',category:'SEO',title:'Legacy',payload:{}})).rejects.toBeInstanceOf(GoneException);
await expect(controller.create({department:'SEO',category:'SEO',title:'Legacy',payload:{}})).rejects.toMatchObject({status:410});
expect(access).not.toHaveBeenCalled();
});
it('decide missing, {decision:APPROVED} returns 410 without reading or writing persistence',async()=>{
await expect(controller.decide('missing', {decision:'APPROVED'})).rejects.toBeInstanceOf(GoneException);
await expect(controller.decide('missing', {decision:'APPROVED'})).rejects.toMatchObject({status:410});
expect(access).not.toHaveBeenCalled();
});
it('decide missing, {decision:REJECTED} returns 410 without reading or writing persistence',async()=>{
await expect(controller.decide('missing', {decision:'REJECTED'})).rejects.toBeInstanceOf(GoneException);
await expect(controller.decide('missing', {decision:'REJECTED'})).rejects.toMatchObject({status:410});
expect(access).not.toHaveBeenCalled();
});
});