288 lines
12 KiB
TypeScript
288 lines
12 KiB
TypeScript
import "module-alias/register";
|
|
import "reflect-metadata";
|
|
import { OfficeFolderHasCustomers, OfficeFolderHasStakeholders, PrismaClient } from "prisma/prisma-client";
|
|
import { customer, customer_, deedType, documentType, documentType_, office, officeFolder, officeFolder_, user, user_ } from "@Test/config/MockedData";
|
|
import Container from "typedi";
|
|
import OfficeFoldersRepository from "@Repositories/OfficeFoldersRepository";
|
|
import OfficeFolderService from "@Services/super-admin/OfficeFoldersService/OfficeFoldersService";
|
|
import { initCustomers, initDeedType, initDocumentType, initOffice, initUsers } from "@Test/config/Init";
|
|
import { OfficeFolder } from "le-coffre-resources/dist/SuperAdmin";
|
|
import DeedTypesService from "@Services/super-admin/DeedTypesService/DeedTypesService";
|
|
import DeedsRepository from "@Repositories/DeedsRepository";
|
|
|
|
const prisma = new PrismaClient();
|
|
|
|
const OfficeFolderServiceTest = new OfficeFolderService(Container.get(OfficeFoldersRepository), Container.get(DeedTypesService), Container.get(DeedsRepository));
|
|
|
|
beforeAll(async () => {
|
|
office.uid = (await initOffice(office)).uid;
|
|
documentType.uid = (await initDocumentType(documentType, office)).uid;
|
|
documentType_.uid = (await initDocumentType(documentType_, office)).uid;
|
|
deedType.uid = (await initDeedType(deedType, office, [documentType.uid])).uid;
|
|
user.uid = (await initUsers(user)).uid;
|
|
user_.uid = (await initUsers(user_)).uid;
|
|
customer.uid = (await initCustomers(customer)).uid;
|
|
customer_.uid = (await initCustomers(customer_)).uid;
|
|
});
|
|
|
|
afterAll(async () => {
|
|
/*
|
|
* Clean database after all tests execution.
|
|
* Due to cascade deletion, if addresses are deleted, all items following tables are dropped: contacts, customers, offices
|
|
*/
|
|
const deleteDeedTypes = prisma.deedTypes.deleteMany();
|
|
const deleteAddresses = prisma.addresses.deleteMany();
|
|
await prisma.$transaction([deleteDeedTypes, deleteAddresses]);
|
|
await prisma.$disconnect();
|
|
});
|
|
|
|
describe("test create function", () => {
|
|
it("should not create a new office folder if deed type is unknown", async () => {
|
|
let officeFolderWithoutDeedTypeUid: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
|
|
officeFolderWithoutDeedTypeUid.deed!.deed_type!.uid = "random uid";
|
|
// try to create a new deed with unknown deed type
|
|
async function createOfficeFolderWithUnknownDeedType() {
|
|
await OfficeFolderServiceTest.create(officeFolderWithoutDeedTypeUid);
|
|
}
|
|
await expect(createOfficeFolderWithUnknownDeedType).rejects.toThrow();
|
|
});
|
|
|
|
it("should not create a new office folder if deed type is archived", async () => {
|
|
let officeFolderWithArchivatedDeedType: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
|
|
// try to create a new deed with unknown deed type
|
|
async function createOfficeFolderWithArchivedDeedType() {
|
|
await OfficeFolderServiceTest.create(officeFolderWithArchivatedDeedType);
|
|
}
|
|
await expect(createOfficeFolderWithArchivedDeedType).rejects.toThrow("deed type is archived");
|
|
});
|
|
|
|
it("should create a new office folder based on existing deed type", async () => {
|
|
const officeFolderCreated = await OfficeFolderServiceTest.create(officeFolder);
|
|
|
|
const deedCreated = await prisma.deeds.findUniqueOrThrow({ where: { uid: officeFolderCreated.deed_uid } });
|
|
|
|
expect(officeFolderCreated.name).toEqual(officeFolder.name);
|
|
expect(officeFolderCreated.folder_number).toEqual(officeFolder.folder_number);
|
|
expect(officeFolderCreated.description).toEqual(officeFolder.description);
|
|
expect(officeFolderCreated.archived_description).toEqual(null);
|
|
expect(officeFolderCreated.status).toEqual("LIVE");
|
|
expect(officeFolderCreated.office_uid).toEqual(officeFolder.office!.uid);
|
|
expect(deedCreated.deed_type_uid).toEqual(officeFolder.deed!.deed_type!.uid);
|
|
});
|
|
|
|
it("should contains stakeholders", async () => {
|
|
const officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
|
|
include: { office_folder_has_stakeholder: true },
|
|
});
|
|
const stakeholderRelation = await prisma.officeFolderHasStakeholders.findUniqueOrThrow({
|
|
where: {
|
|
office_folder_uid_user_stakeholder_uid: {
|
|
user_stakeholder_uid: user.uid!,
|
|
office_folder_uid: officeFolderCreated.uid,
|
|
},
|
|
},
|
|
});
|
|
const stakeholderRelation_ = await prisma.officeFolderHasStakeholders.findUniqueOrThrow({
|
|
where: {
|
|
office_folder_uid_user_stakeholder_uid: {
|
|
user_stakeholder_uid: user_.uid!,
|
|
office_folder_uid: officeFolderCreated.uid,
|
|
},
|
|
},
|
|
});
|
|
expect(officeFolderCreated.office_folder_has_stakeholder.length).toEqual(2);
|
|
const stakeholder: OfficeFolderHasStakeholders = {
|
|
uid: stakeholderRelation.uid,
|
|
office_folder_uid: officeFolderCreated.uid,
|
|
user_stakeholder_uid: user.uid!,
|
|
created_at: officeFolderCreated.created_at,
|
|
updated_at: officeFolderCreated.updated_at,
|
|
};
|
|
const stakeholder_: OfficeFolderHasStakeholders = {
|
|
uid: stakeholderRelation_.uid,
|
|
office_folder_uid: officeFolderCreated.uid,
|
|
user_stakeholder_uid: user_.uid!,
|
|
created_at: officeFolderCreated.created_at,
|
|
updated_at: officeFolderCreated.updated_at,
|
|
};
|
|
expect(officeFolderCreated.office_folder_has_stakeholder).toEqual(expect.arrayContaining([stakeholder, stakeholder_]));
|
|
});
|
|
|
|
it("should not create a new office folder with folder number already created", async () => {
|
|
let officeFolderWithSameFolderNumber: OfficeFolder = JSON.parse(JSON.stringify(officeFolder_));
|
|
officeFolderWithSameFolderNumber.folder_number = officeFolder.folder_number;
|
|
// try to create a new deed with unknown deed type
|
|
async function createOfficeFolderWithSameFolderNumber() {
|
|
await OfficeFolderServiceTest.create(officeFolderWithSameFolderNumber);
|
|
}
|
|
await expect(createOfficeFolderWithSameFolderNumber).rejects.toThrow();
|
|
});
|
|
|
|
it("should not create a new office folder if deed type is archived", async () => {
|
|
await prisma.deedTypes.update({ where: { uid: deedType.uid }, data: { archived_at: new Date(Date.now()) } });
|
|
// try to create a new deed with archivated deed type
|
|
async function createDeedWithArchivatedDeedType() {
|
|
await OfficeFolderServiceTest.create(officeFolder);
|
|
}
|
|
await expect(createDeedWithArchivatedDeedType).rejects.toThrow("deed type is archived");
|
|
});
|
|
});
|
|
|
|
describe("test update function", () => {
|
|
it("should add customers", async () => {
|
|
let officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
|
|
include: { office_folder_has_customers: true },
|
|
});
|
|
|
|
expect(officeFolderCreated.office_folder_has_customers).toEqual([]);
|
|
// mocked data contains the customers
|
|
await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolder);
|
|
|
|
const customerRelation = await prisma.officeFolderHasCustomers.findUniqueOrThrow({
|
|
where: {
|
|
office_folder_uid_customer_uid: {
|
|
customer_uid: customer.uid!,
|
|
office_folder_uid: officeFolderCreated.uid,
|
|
},
|
|
},
|
|
});
|
|
const customerRelation_ = await prisma.officeFolderHasCustomers.findUniqueOrThrow({
|
|
where: {
|
|
office_folder_uid_customer_uid: {
|
|
customer_uid: customer_.uid!,
|
|
office_folder_uid: officeFolderCreated.uid,
|
|
},
|
|
},
|
|
});
|
|
|
|
officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
|
|
include: { office_folder_has_customers: true },
|
|
});
|
|
|
|
expect(officeFolderCreated.office_folder_has_customers.length).toEqual(2);
|
|
const officeFolderHasCustomer: OfficeFolderHasCustomers = {
|
|
uid: customerRelation.uid,
|
|
office_folder_uid: officeFolderCreated.uid,
|
|
customer_uid: customer.uid!,
|
|
created_at: customerRelation.created_at,
|
|
updated_at: customerRelation.updated_at,
|
|
};
|
|
const officeFolderHasCustomer_: OfficeFolderHasCustomers = {
|
|
uid: customerRelation_.uid,
|
|
office_folder_uid: officeFolderCreated.uid,
|
|
customer_uid: customer_.uid!,
|
|
created_at: customerRelation_.created_at,
|
|
updated_at: customerRelation_.updated_at,
|
|
};
|
|
expect(officeFolderCreated.office_folder_has_customers).toEqual(
|
|
expect.arrayContaining([officeFolderHasCustomer, officeFolderHasCustomer_]),
|
|
);
|
|
});
|
|
|
|
it("should remove customers", async () => {
|
|
let officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
|
|
include: { office_folder_has_customers: true },
|
|
});
|
|
|
|
expect(officeFolderCreated.office_folder_has_customers.length).toEqual(2);
|
|
|
|
let officeFolderWithLessCustomers: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
|
|
officeFolderWithLessCustomers.office_folder_has_customers!.pop();
|
|
// mocked data contains the customers
|
|
await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolderWithLessCustomers);
|
|
|
|
const customerRelation = await prisma.officeFolderHasCustomers.findUniqueOrThrow({
|
|
where: {
|
|
office_folder_uid_customer_uid: {
|
|
customer_uid: customer.uid!,
|
|
office_folder_uid: officeFolderCreated.uid,
|
|
},
|
|
},
|
|
});
|
|
|
|
officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
|
|
include: { office_folder_has_customers: true },
|
|
});
|
|
|
|
expect(officeFolderCreated.office_folder_has_customers.length).toEqual(1);
|
|
const officeFolderHasCustomer: OfficeFolderHasCustomers = {
|
|
uid: customerRelation.uid,
|
|
office_folder_uid: officeFolderCreated.uid,
|
|
customer_uid: customer.uid!,
|
|
created_at: customerRelation.created_at,
|
|
updated_at: customerRelation.updated_at,
|
|
};
|
|
expect(officeFolderCreated.office_folder_has_customers).toEqual([officeFolderHasCustomer]);
|
|
});
|
|
it("should remove stakeholders", async () => {
|
|
let officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
|
|
include: { office_folder_has_stakeholder: true },
|
|
});
|
|
|
|
expect(officeFolderCreated.office_folder_has_stakeholder.length).toEqual(2);
|
|
|
|
let officeFolderWithLessStakeholders: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
|
|
officeFolderWithLessStakeholders.office_folder_has_stakeholder!.pop();
|
|
// mocked data contains the customers
|
|
await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolderWithLessStakeholders);
|
|
|
|
const stakeholderRelation = await prisma.officeFolderHasStakeholders.findUniqueOrThrow({
|
|
where: {
|
|
office_folder_uid_user_stakeholder_uid: {
|
|
user_stakeholder_uid: user.uid!,
|
|
office_folder_uid: officeFolderCreated.uid,
|
|
},
|
|
},
|
|
});
|
|
|
|
officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
|
|
include: { office_folder_has_stakeholder: true },
|
|
});
|
|
|
|
expect(officeFolderCreated.office_folder_has_stakeholder.length).toEqual(1);
|
|
const officeFolderHasStakeholder: OfficeFolderHasStakeholders = {
|
|
uid: stakeholderRelation.uid,
|
|
office_folder_uid: officeFolderCreated.uid,
|
|
user_stakeholder_uid: user.uid!,
|
|
created_at: stakeholderRelation.created_at,
|
|
updated_at: stakeholderRelation.updated_at,
|
|
};
|
|
expect(officeFolderCreated.office_folder_has_stakeholder).toEqual([officeFolderHasStakeholder]);
|
|
});
|
|
it("should archivate an office folder", async () => {
|
|
const officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({});
|
|
let officeFolderArchived: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
|
|
// mocked data for this office folder is "ARCHIVATED" by default
|
|
officeFolderArchived.archived_description = "folder complete";
|
|
|
|
const officeFolderUpdated = await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolderArchived);
|
|
|
|
expect(officeFolderUpdated.archived_description).toEqual(officeFolderArchived.archived_description);
|
|
expect(officeFolderUpdated.status).toEqual("ARCHIVED");
|
|
});
|
|
it("should unarchivate an office folder", async () => {
|
|
const officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({});
|
|
|
|
expect(officeFolderCreated.archived_description).toEqual("folder complete");
|
|
expect(officeFolderCreated.status).toEqual("ARCHIVED");
|
|
|
|
let officeFolderUnarchived: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
|
|
officeFolderUnarchived.status = "LIVE";
|
|
|
|
const officeFolderUpdated = await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolderUnarchived);
|
|
|
|
expect(officeFolderUpdated.archived_description).toBeNull();
|
|
expect(officeFolderUpdated.status).toEqual("LIVE");
|
|
});
|
|
});
|
|
|
|
describe("test get function", () => {
|
|
it("should return an array of officeFolders", async () => {
|
|
const officeFolders = await OfficeFolderServiceTest.get({});
|
|
|
|
// verify result typing
|
|
expect(officeFolders).toBeInstanceOf(Array<OfficeFolder>);
|
|
expect(officeFolders.length).toEqual(1);
|
|
});
|
|
});
|