forked from Yara724/api
356 lines
12 KiB
TypeScript
356 lines
12 KiB
TypeScript
import { SandHubService } from "./sand-hub.service";
|
|
import {
|
|
ForbiddenException,
|
|
ServiceUnavailableException,
|
|
} from "@nestjs/common";
|
|
import { ExternalInquirySettingsService } from "src/client/external-inquiry-settings.service";
|
|
import { SandHubDetailDto } from "./dto/sand-hub.dto";
|
|
|
|
describe("SandHubService inquiry mocks", () => {
|
|
const httpService = { post: jest.fn() };
|
|
const sandHubDbService = { findOneBySandHubId: jest.fn() };
|
|
const externalInquirySettings = {
|
|
isInquiryLive: jest.fn(),
|
|
getMockCompanyContext: jest.fn(),
|
|
};
|
|
const plateNormalizer = {
|
|
normalizePlateText: (text: string) => text,
|
|
};
|
|
const lookupsService = {
|
|
findLastProcessedCarPolicy: jest.fn(),
|
|
};
|
|
const offlineInquiryService = {
|
|
findPlateInquiry: jest.fn(),
|
|
};
|
|
|
|
let service: SandHubService;
|
|
|
|
const userDetail = {
|
|
nationalCodeOfInsurer: "1234567890",
|
|
plate: {
|
|
leftDigits: 16,
|
|
centerAlphabet: "12",
|
|
centerDigits: 498,
|
|
ir: 60,
|
|
nationalCode: "1234567890",
|
|
},
|
|
} as SandHubDetailDto;
|
|
|
|
beforeEach(() => {
|
|
jest.clearAllMocks();
|
|
process.env.CLIENT_ID = "8";
|
|
delete process.env.FANAVARAN_CLIENT;
|
|
service = new SandHubService(
|
|
httpService as any,
|
|
sandHubDbService as any,
|
|
externalInquirySettings as unknown as ExternalInquirySettingsService,
|
|
plateNormalizer as any,
|
|
offlineInquiryService as any,
|
|
lookupsService as any,
|
|
);
|
|
externalInquirySettings.isInquiryLive.mockResolvedValue(false);
|
|
offlineInquiryService.findPlateInquiry.mockResolvedValue(null);
|
|
externalInquirySettings.getMockCompanyContext.mockResolvedValue({
|
|
companyId: "8",
|
|
companyName: "بیمه پارسیان",
|
|
});
|
|
});
|
|
|
|
it("returns car-body mock without HTTP when carBodyPlate is off", async () => {
|
|
const result = await service.getTejaratCarBodyInquiry(userDetail);
|
|
|
|
expect(httpService.post).not.toHaveBeenCalled();
|
|
expect(externalInquirySettings.isInquiryLive).toHaveBeenCalledWith(
|
|
"carBodyPlate",
|
|
undefined,
|
|
);
|
|
expect(result.raw?.isSuccess).toBe(true);
|
|
expect(result.raw?.data?.companyId).toBe(8);
|
|
expect(result.raw?.data?.companyName).toBe("بیمه پارسیان");
|
|
expect(result.mapped.policyNumber).toBe("1405/1143-70591/220/1/0");
|
|
expect(result.mapped.CompanyName).toBe("بیمه پارسیان");
|
|
expect(result.mapped.companyId).toBe(8);
|
|
expect(result.mapped.insurerNationalCode).toBe("1234567890");
|
|
expect(result.mapped.platePartOne).toBe(16);
|
|
expect(result.mapped.platePartThree).toBe(498);
|
|
});
|
|
|
|
it("uses the processed ESG CAR_BODY lookup and preserves it as raw data", async () => {
|
|
process.env.CLIENT_ID = "8";
|
|
externalInquirySettings.isInquiryLive.mockResolvedValue(true);
|
|
lookupsService.findLastProcessedCarPolicy.mockResolvedValue({
|
|
product: "car-body",
|
|
insuranceLine: "CAR_BODY",
|
|
insuranceLineId: 4,
|
|
policyId: 15292336,
|
|
policy: { CINumber: "70019846985", BeginDate: "1405/05/18" },
|
|
customer: { Name: "سهيل", LastName: "حاجي زاده" },
|
|
vehicle: {
|
|
VIN: "NAAR03HFFRDE07024",
|
|
plaque: {
|
|
leftTwoDigits: "16",
|
|
serialLetter: "ب",
|
|
threeDigits: "498",
|
|
rightTwoDigits: "60",
|
|
},
|
|
},
|
|
});
|
|
|
|
const result = await service.getCarBodyInquiry(userDetail);
|
|
|
|
expect(lookupsService.findLastProcessedCarPolicy).toHaveBeenCalledWith(
|
|
"car-body",
|
|
{
|
|
nationalCode: "1234567890",
|
|
plaqueLeft: "16",
|
|
plaqueLetter: "12",
|
|
plaqueRight: "498",
|
|
plaqueSerial: "60",
|
|
},
|
|
);
|
|
expect(result.source).toBe("ESG_CAR_BODY_INQUIRY");
|
|
expect(result.raw.policyId).toBe(15292336);
|
|
expect(result.mapped.policyNumber).toBe("70019846985");
|
|
expect(httpService.post).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("does not let an offline third-party seed override a live ESG inquiry", async () => {
|
|
process.env.CLIENT_ID = "8";
|
|
externalInquirySettings.isInquiryLive.mockResolvedValue(true);
|
|
offlineInquiryService.findPlateInquiry.mockResolvedValue({
|
|
source: "OFFLINE_SEED_INQUIRY",
|
|
raw: { mocked: true },
|
|
mapped: { PrntPlcyCmpDocNo: "MOCK-POLICY" },
|
|
});
|
|
const esg = jest
|
|
.spyOn(service as any, "makeEsgRequest")
|
|
.mockResolvedValue({
|
|
success: true,
|
|
data: { PrntCmpDocNo: "REAL-ESG-POLICY" },
|
|
});
|
|
|
|
const result = await service.getTejaratBlockInquiry(userDetail);
|
|
|
|
expect(esg).toHaveBeenCalled();
|
|
expect(result.raw).not.toEqual({ mocked: true });
|
|
expect(result.mapped.PrntPlcyCmpDocNo).toBe("REAL-ESG-POLICY");
|
|
});
|
|
|
|
it("rejects a guilty third-party policy issued by another insurer", async () => {
|
|
process.env.CLIENT_ID = "15";
|
|
externalInquirySettings.isInquiryLive.mockResolvedValue(true);
|
|
jest.spyOn(service as any, "makeTejaratRequest").mockResolvedValue({
|
|
CompanyCode: "8",
|
|
CompanyName: "بیمه پارسیان",
|
|
PrntPlcyCmpDocNo: "OTHER-INSURER-POLICY",
|
|
});
|
|
|
|
await expect(
|
|
service.getTejaratBlockInquiry(userDetail, {
|
|
enforceDeploymentClientMatch: true,
|
|
} as any),
|
|
).rejects.toBeInstanceOf(ForbiddenException);
|
|
});
|
|
|
|
it("allows an unchecked third-party policy from another insurer", async () => {
|
|
process.env.CLIENT_ID = "15";
|
|
externalInquirySettings.isInquiryLive.mockResolvedValue(true);
|
|
jest.spyOn(service as any, "makeTejaratRequest").mockResolvedValue({
|
|
CompanyCode: "8",
|
|
CompanyName: "بیمه پارسیان",
|
|
});
|
|
|
|
await expect(service.getTejaratBlockInquiry(userDetail)).resolves.toEqual(
|
|
expect.objectContaining({
|
|
mapped: expect.objectContaining({ CompanyCode: "8" }),
|
|
}),
|
|
);
|
|
});
|
|
|
|
it("rejects a guilty VIN third-party policy issued by another insurer", async () => {
|
|
process.env.CLIENT_ID = "15";
|
|
externalInquirySettings.isInquiryLive.mockResolvedValue(true);
|
|
jest.spyOn(service as any, "makeEsgRequest").mockResolvedValue({
|
|
success: true,
|
|
data: { CmpCod: "8", CmpNam: "بیمه پارسیان" },
|
|
});
|
|
|
|
await expect(
|
|
service.getPolicyByChassisInquiry("NAAR03HFFRDE07024", {
|
|
enforceDeploymentClientMatch: true,
|
|
}),
|
|
).rejects.toBeInstanceOf(ForbiddenException);
|
|
});
|
|
|
|
it("does not accept a policy when CLIENT_ID is not configured", async () => {
|
|
delete process.env.CLIENT_ID;
|
|
|
|
await expect(service.getCarBodyInquiry(userDetail)).rejects.toBeInstanceOf(
|
|
ServiceUnavailableException,
|
|
);
|
|
});
|
|
|
|
it("rejects a CAR_BODY policy from another insurer on the Parsian lookup route", async () => {
|
|
process.env.CLIENT_ID = "15";
|
|
process.env.FANAVARAN_CLIENT = "parsian";
|
|
externalInquirySettings.isInquiryLive.mockResolvedValue(true);
|
|
lookupsService.findLastProcessedCarPolicy.mockResolvedValue({
|
|
policy: { CINumber: "70019846985" },
|
|
customer: {},
|
|
vehicle: {},
|
|
});
|
|
|
|
await expect(service.getCarBodyInquiry(userDetail)).rejects.toBeInstanceOf(
|
|
ForbiddenException,
|
|
);
|
|
});
|
|
|
|
it("rejects a CAR_BODY policy from another insurer on the Tejarat lookup route", async () => {
|
|
process.env.CLIENT_ID = "15";
|
|
jest.spyOn(service, "getTejaratCarBodyInquiry").mockResolvedValue({
|
|
raw: { data: { companyId: "8" } },
|
|
mapped: { companyId: "8", CompanyCode: "8" },
|
|
});
|
|
|
|
await expect(service.getCarBodyInquiry(userDetail)).rejects.toBeInstanceOf(
|
|
ForbiddenException,
|
|
);
|
|
});
|
|
|
|
it("uses the processed CAR_BODY lookup when the active Fanavaran client is Parsian", async () => {
|
|
process.env.FANAVARAN_CLIENT = "parsian";
|
|
externalInquirySettings.isInquiryLive.mockResolvedValue(true);
|
|
lookupsService.findLastProcessedCarPolicy.mockResolvedValue({
|
|
policy: { CINumber: "70019846985" },
|
|
customer: {},
|
|
vehicle: {},
|
|
});
|
|
const tejarat = jest
|
|
.spyOn(service, "getTejaratCarBodyInquiry")
|
|
.mockResolvedValue({ raw: { mocked: true }, mapped: {} });
|
|
|
|
const result = await service.getCarBodyInquiry(userDetail);
|
|
|
|
expect(lookupsService.findLastProcessedCarPolicy).toHaveBeenCalledWith(
|
|
"car-body",
|
|
expect.objectContaining({ nationalCode: "1234567890" }),
|
|
);
|
|
expect(tejarat).not.toHaveBeenCalled();
|
|
expect(result.raw).not.toEqual({ mocked: true });
|
|
});
|
|
|
|
it("keeps ESG car-body inquiry in mock mode when the per-client toggle is off", async () => {
|
|
process.env.CLIENT_ID = "8";
|
|
|
|
const result = await service.getCarBodyInquiry(userDetail);
|
|
|
|
expect(lookupsService.findLastProcessedCarPolicy).not.toHaveBeenCalled();
|
|
expect(result.source).toBe("ESG_CAR_BODY_INQUIRY");
|
|
expect(result.raw?.isSuccess).toBe(true);
|
|
expect(httpService.post).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it("uses the VIN lookup and VIN audit source for ESG car-body VIN inquiries", async () => {
|
|
process.env.CLIENT_ID = "8";
|
|
externalInquirySettings.isInquiryLive.mockResolvedValue(true);
|
|
lookupsService.findLastProcessedCarPolicy.mockResolvedValue({
|
|
policy: { CINumber: "70019846985" },
|
|
customer: {},
|
|
vehicle: {},
|
|
});
|
|
|
|
const result = await service.getCarBodyInquiry({
|
|
nationalCodeOfInsurer: "1234567890",
|
|
plate: "NAAR03HFFRDE07024",
|
|
});
|
|
|
|
expect(lookupsService.findLastProcessedCarPolicy).toHaveBeenCalledWith(
|
|
"car-body",
|
|
{ nationalCode: "1234567890", vin: "NAAR03HFFRDE07024" },
|
|
);
|
|
expect(result.source).toBe("ESG_CAR_BODY_VIN_INQUIRY");
|
|
});
|
|
|
|
it("uses car-body mock shape in Tejarat helper when inquiry is off", async () => {
|
|
const raw = await (service as any).makeTejaratRequest(
|
|
"http://example/block-inquiry-tejarat/badane",
|
|
{
|
|
part1: 16,
|
|
part2: 12,
|
|
part3: 498,
|
|
part4: 60,
|
|
nationalCode: "1234567890",
|
|
},
|
|
"carBodyPlate",
|
|
);
|
|
|
|
expect(httpService.post).not.toHaveBeenCalled();
|
|
expect(raw?.data?.printNumber).toBe("1405/1143-70591/220/1/0");
|
|
expect(raw?.data?.companyName).toBe("بیمه پارسیان");
|
|
});
|
|
|
|
it("returns third-party plate mock for block inquiry when inquiry is off", async () => {
|
|
const result = await service.getTejaratBlockInquiry(userDetail);
|
|
|
|
expect(httpService.post).not.toHaveBeenCalled();
|
|
expect(result.mapped?.CompanyName).toBe("بیمه پارسیان");
|
|
expect(result.mapped?.CompanyCode).toBe("8");
|
|
// PrntPlcyCmpDocNo must be populated from the mock raw field
|
|
expect(result.mapped?.PrntPlcyCmpDocNo).toBe("1404/1143-70591/200/123");
|
|
});
|
|
|
|
it("maps printNumber → PrntPlcyCmpDocNo when raw response uses new field name", async () => {
|
|
// Simulate a real-API response where the policy number arrives as printNumber
|
|
const rawNewFormat = {
|
|
printNumber: "1405/1143-NEWAPI/200/1",
|
|
CompanyName: "بیمه آزمایشی",
|
|
CompanyCode: "99",
|
|
FinancialCvrCptl: "5000000000",
|
|
IssueDate: "1405/01/01",
|
|
EndDate: "1406/01/01",
|
|
};
|
|
const mapped = (service as any).mapNewApiResponseToOldFormat(rawNewFormat);
|
|
|
|
expect(mapped.PrntPlcyCmpDocNo).toBe("1405/1143-NEWAPI/200/1");
|
|
});
|
|
|
|
it("maps insuranceNumber → PrntPlcyCmpDocNo when raw response uses legacy field name", async () => {
|
|
const rawLegacy = {
|
|
insuranceNumber: "1405/1143-LEGACY/200/1",
|
|
CompanyName: "بیمه آزمایشی",
|
|
CompanyCode: "99",
|
|
};
|
|
const mapped = (service as any).mapNewApiResponseToOldFormat(rawLegacy);
|
|
|
|
expect(mapped.PrntPlcyCmpDocNo).toBe("1405/1143-LEGACY/200/1");
|
|
});
|
|
|
|
it("maps ESG PrntCmpDocNo → PrntPlcyCmpDocNo and preserves begin/end dates", () => {
|
|
const mapped = (service as any).mapEsgPolicyByPlateToOldFormat({
|
|
success: true,
|
|
data: {
|
|
PrntCmpDocNo: "1110/111130/404/003412",
|
|
LastCmpDocNo: "1110/111130/403/002650",
|
|
PlcyUnqCod: "16018466143",
|
|
HBgnDte: "1404/10/23",
|
|
HEndDte: "1405/10/23",
|
|
HIsuDte: "1404/10/21",
|
|
VIN: "IRFC891V7D2301065",
|
|
MtrNum: "13389030167",
|
|
ShsNum: "NAAP41FD5BJ301065",
|
|
PrdDte: "1389",
|
|
CmpCod: "8",
|
|
CmpNam: "بيمه پارسيان",
|
|
},
|
|
});
|
|
|
|
expect(mapped.PrntPlcyCmpDocNo).toBe("1110/111130/404/003412");
|
|
expect(mapped.ThirdPolicyCode).toBe("16018466143");
|
|
expect(mapped.StartDate).toBe("1404/10/23");
|
|
expect(mapped.EndDate).toBe("1405/10/23");
|
|
expect(mapped.IssueDate).toBe("1404/10/21");
|
|
expect(mapped.VIN).toBe("IRFC891V7D2301065");
|
|
expect(mapped.ModelField).toBe("1389");
|
|
});
|
|
});
|