mail/back/test/mail/saveMessage-test.ts

jest.mock("mysql");
import mysql from "mysql";
mysql.createConnection = jest.fn();
mysql.createConnection.mockImplementation(() => {
    return { connect: () => new Promise((resolve, rejects) => resolve(true)) };
});

import saveMessageDatabase from "../test-utils/db/test-saveMessage";
import { generateAttrs, generateUsers } from "../test-utils/test-attrsUtils";
import { jest, describe, it, expect } from "@jest/globals";
import { mocked } from "jest-mock";

import registerMessageInApp, { RoomType } from "../../mails/saveMessage";

const db = new saveMessageDatabase(generateUsers(5));
const ownUser = db.users[0];
const messageId = 1;
const boxId = 1;

jest.mock("../../db/utils/mail", () => {
    return {
        findRoomByOwner: jest.fn(),
        getAddresseId: jest.fn(),
        getUserIdOfMailbox: jest.fn(),
    };
});
jest.mock("../../db/saveMessage-db", () => {
    return {
        createRoom: jest.fn(),
        registerMessageInRoom: jest.fn(),
        isRoomGroup: jest.fn(),
        findRoomsFromMessage: jest.fn(),
        hasSameMembersAsParent: jest.fn(),
        registerThread: jest.fn(),
        registerMember: jest.fn(),
        getAllMembers: jest.fn(),
        getThreadInfo: jest.fn(),
        incrementNotSeenRoom: jest.fn(),
    };
});
import { getAddresseId, getUserIdOfMailbox, findRoomByOwner } from "../../db/utils/mail";
import {
    createRoom,
    registerMessageInRoom,
    isRoomGroup,
    findRoomsFromMessage,
    hasSameMembersAsParent,
    registerThread,
    registerMember,
    getAllMembers,
    getThreadInfo,
    incrementNotSeenRoom,
} from "../../db/saveMessage-db";
import { AttrsWithEnvelope } from "../../interfaces/mail/attrs.interface";
// todo esbuild
// new message from us
//     to multiple people -> room
//         if response has same member => group
//         if response is dm => channel
//     to one person => dm

// new message from other
//     to only me -> room
//         if no reply to multiple message => channel
//         else => dm
//     to multiple people -> room
//         // make it better
//         if multiple members reply -> group
//         if only me reply -> channel

beforeAll(async () => {
    mocked(getAddresseId).mockImplementation(db.getAddresseId);
    mocked(getUserIdOfMailbox).mockImplementation(db.getUserIdOfMailbox);
    mocked(findRoomByOwner).mockImplementation(db.findRoomByOwner);

    mocked(createRoom).mockImplementation(db.createRoom);
    mocked(registerMessageInRoom).mockImplementation(db.registerMessageInRoom);
    mocked(isRoomGroup).mockImplementation(db.isRoomGroup);
    mocked(findRoomsFromMessage).mockImplementation(db.findRoomsFromMessage);
    mocked(hasSameMembersAsParent).mockImplementation(db.hasSameMembersAsParent);
    mocked(registerThread).mockImplementation(db.registerThread);
    mocked(registerMember).mockImplementation(db.registerMember);
    mocked(getAllMembers).mockImplementation(db.getAllMembers);
    mocked(getThreadInfo).mockImplementation(db.getThreadInfo);
    mocked(incrementNotSeenRoom).mockImplementation(db.incrementNotSeenRoom);
});


const msgFromUs_1: { attrs: AttrsWithEnvelope; message_id: number } = {
    attrs: generateAttrs({ from: [ownUser.user], to: [db.users[1].user], messageId: "1" }),
    message_id: 1,
};
const replyTo1_2: { attrs: AttrsWithEnvelope; message_id: number } = {
    attrs: generateAttrs({ from: [ownUser.user], to: [db.users[1].user], messageId: "2", inReplyTo: "1" }),
    message_id: 2,
};

const replyTo2_3: { attrs: AttrsWithEnvelope; message_id: number } = {
    attrs: generateAttrs({ from: [ownUser.user], to: [db.users[1].user, db.users[2].user], messageId: "3", inReplyTo: "2" }),
    message_id: 3,
};

beforeEach(async () => {
    db.clear();
    db.messages.push(msgFromUs_1);
    db.messages.push(replyTo1_2);
    db.messages.push(replyTo2_3);
});

describe("saveMessage", () => {
    
    describe("functions", () => {
        it("isFromUs", async () => {
            const attrs = generateAttrs({ from: [ownUser.user], to: [db.users[1].user] });
            const register = new registerMessageInApp(messageId, attrs, boxId);
            await register.init();
            const res = await register.isFromUs();

            expect(res).toBe(true);

            const attrs2 = generateAttrs({ from: [db.users[2].user], to: [db.users[1].user] });
            const register2 = new registerMessageInApp(messageId, attrs2, boxId);
            await register2.init();
            const res2 = await register2.isFromUs();

            expect(res2).toBe(false);
        });
    });
    describe("room creation", () => {
        it("should create a DM when there is a new first message from us to one recipient", async () => {
            const attrs = generateAttrs({ from: [ownUser.user], to: [db.users[1].user] });

            const register = new registerMessageInApp(messageId, attrs, boxId);

            const createOrRegisterOnExistence = jest
                .spyOn(register, "createOrRegisterOnExistence")
                .mockImplementation((owner: number, roomType: RoomType) => new Promise((resolve, reject) => resolve()));

            await register.save();

            expect(createOrRegisterOnExistence).toHaveBeenCalledWith(db.users[1].id, RoomType.DM);
        });
        it("should create a ROOM when there is a new first message from us to multiple recipients", async () => {
            const attrs = generateAttrs({ from: [ownUser.user], to: [db.users[1].user, db.users[2].user] });

            const register = new registerMessageInApp(messageId, attrs, boxId);

            const initiateRoom = jest
                .spyOn(register, "initiateRoom")
                .mockImplementation((owner: number, roomType: RoomType) => Promise.resolve(1));

            await register.save();

            expect(initiateRoom).toHaveBeenCalledWith(ownUser.id, RoomType.ROOM);
        });
        // it("response to new first message to multiple recipients with same members should change room type to GROUP", () => {

        // });
        // it("response to new first message to multiple recipients with different members should change room type to CHANNEL", () => {

        // });
        it("should create a ROOM when there is a new first message from other to me only", async () => {
            const attrs = generateAttrs({ from: [db.users[1].user], to: [ownUser.user] });

            const register = new registerMessageInApp(messageId, attrs, boxId);

            const createOrRegisterOnExistence = jest
                .spyOn(register, "createOrRegisterOnExistence")
                .mockImplementation((owner: number, roomType: RoomType) => {
                    return new Promise((resolve, reject) => resolve());
                });

            await register.save();

            expect(createOrRegisterOnExistence).toHaveBeenCalledWith(db.users[1].id, RoomType.ROOM);
        });
        it("should create THREAD when reply to a message in a DM", async () => {
            let register = new registerMessageInApp(msgFromUs_1.message_id, msgFromUs_1.attrs, boxId);
            await register.save();
            register = new registerMessageInApp(replyTo1_2.message_id, replyTo1_2.attrs, boxId);
            await register.save();
    
            const thread = db.rooms.find((room) => room.is_thread)
            expect(thread.room_type).toBe(RoomType.THREAD);
            expect(thread.root_id).toBe(0);
            expect(thread.parent_id).toBe(0);
        });
    
        it("should create THREAD when reply in THREAD with different members", async() => {
            let register = new registerMessageInApp(msgFromUs_1.message_id, msgFromUs_1.attrs, boxId);
            await register.save();
            register = new registerMessageInApp(replyTo1_2.message_id, replyTo1_2.attrs, boxId);
            await register.save();
            register = new registerMessageInApp(replyTo2_3.message_id, replyTo2_3.attrs, boxId);
            await register.save();
    
            const threads = db.rooms.filter((room) => room.is_thread);
            expect(threads).toHaveLength(2);
            const thread = threads[1];
            expect(thread.room_type).toBe(RoomType.THREAD);
            expect(thread.root_id).toBe(0);
            expect(thread.parent_id).toBe(1);
            expect(thread.members).toHaveLength(3);
        });
    });
    describe("replies", () => {
        it("", () => {});
    });
    describe("unseen behavior", () => {
        it("should add unseen in room when a message creates a room", () => {});

        it("should add unseen in room when a message joins a room", () => {});

        it("should add unseen in root room and thread when new message creates a thread", () => {});

        it("should add unseen in root room and thread when new message joins in thread", () => {});
    });
});