lecoffre-back/src/test/services/super-admin/OfficeFolderService.test.ts

import "module-alias/register";
import "reflect-metadata";
import { 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)).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: { stakeholders: true },
		});
		expect(officeFolderCreated.stakeholders).toEqual([user, user_]);
	});

	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: { customers: true },
		});

		expect(officeFolderCreated.customers).toEqual([]);
		// mocked data contains the customers
		await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolder);

		officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
			include: { customers: true },
		});

		expect(officeFolderCreated.customers.length).toEqual([customer, customer_].length);
	});

	it("should remove customers", async () => {
		let officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
			include: { customers: true },
		});

		expect(officeFolderCreated.customers.length).toEqual(2);

		let officeFolderWithLessCustomers: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
		officeFolderWithLessCustomers.customers!.pop();
		// mocked data contains the customers
		await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolderWithLessCustomers);

		expect(officeFolderCreated.customers.length).toEqual([customer]);
	});
	it("should remove stakeholders", async () => {
		let officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
			include: { stakeholders: true },
		});

		expect(officeFolderCreated.stakeholders.length).toEqual(2);

		let officeFolderWithLessStakeholders: OfficeFolder = JSON.parse(JSON.stringify(officeFolder));
		officeFolderWithLessStakeholders.stakeholders!.pop();
		// mocked data contains the customers
		await OfficeFolderServiceTest.update(officeFolderCreated.uid, officeFolderWithLessStakeholders);

		officeFolderCreated = await prisma.officeFolders.findFirstOrThrow({
			include: { stakeholders: true },
		});

		expect(officeFolderCreated.stakeholders).toEqual([user]);
	});
	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);
	});
});