advancements in tests

back/db/saveMessage-db.ts

@@ -1,3 +1,5 @@
+import { RoomType } from "../mails/saveMessage";
+import { hasSameElements } from "../utils/array";
 import { transformEmojis } from "../utils/string";
 import { execQueryAsync, execQueryAsyncWithId, execQuery } from "./db";
 import { queryFromId, queryToId, queryCcId } from "./utils/addressQueries";
@@ -25,8 +27,8 @@ export async function createRoom(
     roomName: string | null | undefined,
     ownerId: number,
     messageId: number,
-    roomType: number,
+    roomType: RoomType,
-) {
+): Promise<number> {
     if (!roomName) roomName = "No room name";
     roomName = transformEmojis(roomName);
     const query = `INSERT IGNORE INTO app_room (room_name, owner_id, message_id, room_type) VALUES (?, ?, ?, ?)`;
@@ -35,21 +37,13 @@ export async function createRoom(
 }
 
 // todo date not good
-export async function registerMessageInRoom(
+export async function registerMessageInRoom(messageId: number, roomId: number, idate: string | undefined | null) {
-    messageId: number,
-    roomId: number,
-    isSeen: boolean,
-    idate: string | undefined | null,
-) {
     if (!idate) idate = new Date().toString();
     const query = `INSERT IGNORE INTO app_room_message (message_id, room_id) VALUES (?, ?)`;
     const values = [messageId, roomId];
     await execQueryAsync(query, values);
 
     updateLastUpdateRoom(roomId, idate);
-    // if (!isSeen) {
-    //     incrementNotSeenRoom(roomId);
-    // }
 }
 
 export function updateLastUpdateRoom(roomId: number, idate: string) {
@@ -58,11 +52,13 @@ export function updateLastUpdateRoom(roomId: number, idate: string) {
     execQuery(query, values);
 }
 
-export function incrementNotSeenRoom(roomId: number) {
+export async function incrementNotSeenRoom(roomId: number) {
-    // todo
+    const query = `UPDATE app_room SET unseen = unseen + 1 WHERE room_id = ?`;
+    const values = [roomId];
+    execQuery(query, values);
 }
 
-export async function getRoomInfo(messageID: string): Promise<{ room_id: number; root_id: number }[]> {
+export async function getThreadInfo(messageID: string): Promise<{ room_id: number; root_id: number }[]> {
     const query = `
         SELECT 
             app_room.room_id
@@ -92,14 +88,18 @@ export async function isRoomGroup(roomId: number): Promise<boolean> {
     });
 }
 
-export async function findRoomsFromMessage(messageID: string) {
+export async function findRoomsFromMessage(messageID: string): Promise<{ room_id: number }[]> {
     // todo find message in room not started
-    const query = `SELECT room_id FROM app_room_message WHERE message_id = ? ORDER BY room_id`;
+    const query = `
+        SELECT room_id FROM app_room_message 
+        INNER JOIN message ON message.message_id = app_room_message.message_id
+        WHERE message.messageID = ? ORDER BY room_id
+    `;
     const values = [messageID];
     return await execQueryAsync(query, values);
 }
 
-export async function hasSameMembersAsParent(messageId: number, messageID: string) {
+export async function hasSameMembersAsParent(messageId: number, messageID: string): Promise<boolean> {
     const query1 = `
         SELECT 
             GROUP_CONCAT(fromT.address_id) AS fromA,
@@ -137,8 +137,5 @@ export async function hasSameMembersAsParent(messageId: number, messageID: strin
         .concat(addressesMsg2[0]?.toA?.split(","))
         .concat(addressesMsg2[0]?.ccA?.split(","));
 
-    return (
+    return hasSameElements(addressesMsg1, addressesMsg2);
-        addressesMsg1.length == addressesMsg2.length &&
-        addressesMsg1.reduce((a, b) => a && addressesMsg2.includes(b), true)
-    );
 }

back/db/utils/mail.ts

@@ -23,6 +23,7 @@ export async function findRoomByOwner(ownerId: number): Promise<{ room_id: numbe
 }
 
 export async function getUserIdOfMailbox(boxId: number): Promise<{ user_id: number }[]> {
+    console.log("fuckdsvreghiu")
     const query = `
         SELECT app_account.user_id
         FROM mailbox 

back/mails/saveMessage.ts

@@ -7,7 +7,8 @@ import {
     registerThread,
     registerMember,
     getAllMembers,
-    getRoomInfo,
+    getThreadInfo,
+    incrementNotSeenRoom,
 } from "../db/saveMessage-db";
 
 import { findRoomByOwner, getAddresseId, getUserIdOfMailbox } from "../db/utils/mail";
@@ -22,13 +23,13 @@ function createAddress(elt: User): string {
     return `${elt.mailbox}@${elt.host}`;
 }
 
-export const roomType = {
+export enum RoomType {
-    ROOM: 0,
+    ROOM = 0,
-    CHANNEL: 1,
+    CHANNEL = 1,
-    GROUP: 2,
+    GROUP = 2,
-    DM: 3,
+    DM = 3,
-    THREAD: 4,
+    THREAD = 4,
-};
+}
 
 export default class RegisterMessageInApp {
     messageId: number;
@@ -73,6 +74,12 @@ export default class RegisterMessageInApp {
         return this.ownerId == this.userId;
     }
 
+    async incrementNotSeen(roomId: number) {
+        if (!this.isSeen) {
+            await incrementNotSeenRoom(roomId);
+        }
+    }
+
     async registerMembers(roomId: number) {
         getAllMembers(this.messageId).then((res) => {
             const data = res[0].id.split(",");
@@ -82,42 +89,49 @@ export default class RegisterMessageInApp {
         });
     }
 
-    async initiateRoom(owner: number, roomType: number) {
+    async initiateRoom(owner: number, roomType: RoomType) {
         try {
             const roomId = await createRoom(this.envelope.subject, owner, this.messageId, roomType);
-            await registerMessageInRoom(this.messageId, roomId, this.isSeen, this.envelope.date);
+            await registerMessageInRoom(this.messageId, roomId, this.envelope.date);
-            this.registerMembers(roomId);
+            await this.incrementNotSeen(roomId);
+            await this.registerMembers(roomId);
             return roomId;
         } catch (err) {
             logger.err(err);
         }
     }
 
-    async createOrRegisterOnExistence(owner: number, roomType: number) {
+    async createOrRegisterOnExistence(owner: number, roomType: RoomType) {
         await findRoomByOwner(owner).then(async (res) => {
             if (res.length == 0) {
                 // first message with this sender
                 await this.initiateRoom(owner, roomType);
             } else {
                 // not a reply, add to the list of message if this sender
-                await registerMessageInRoom(this.messageId, res[0].room_id, this.isSeen, this.envelope.date);
+                await registerMessageInRoom(this.messageId, res[0].room_id, this.envelope.date);
+                await this.incrementNotSeen(res[0].room_id);
+
             }
         });
     }
 
     async initiateThread() {
-        await createRoom(this.envelope.subject, this.ownerId, this.messageId, roomType.THREAD).then(
+        await createRoom(this.envelope.subject, this.ownerId, this.messageId, RoomType.THREAD).then(
-            async (roomId: number) => {
+            async (threadId: number) => {
                 // find parent room infos
-                await getRoomInfo(this.inReplyTo).then(async (room) => {
+                let roomId: number;
+                await getThreadInfo(this.inReplyTo).then(async (room) => {
                     // todo room not lenght, reply to transfer ?
+                    roomId = room[0].room_id;
                     let root_id = room[0].root_id;
-                    if (!root_id) root_id = room[0].room_id;
+                    if (!root_id) root_id = roomId;
-                    await registerThread(roomId, room[0].room_id, root_id);
+                    await registerThread(threadId, room[0].room_id, root_id);
                 });
-                // impl register previous message ?
+                // impl register previous message or go back
-                await registerMessageInRoom(this.messageId, roomId, this.isSeen, this.envelope.date);
+                await registerMessageInRoom(this.messageId, threadId, this.envelope.date);
-                await this.registerMembers(roomId);
+                await this.incrementNotSeen(roomId);
+                await this.incrementNotSeen(threadId);
+                await this.registerMembers(threadId);
             },
         );
     }
@@ -125,7 +139,8 @@ export default class RegisterMessageInApp {
     async createOrRegisterOnMembers(roomId: number) {
         const hasSameMembers = await hasSameMembersAsParent(this.messageId, this.inReplyTo);
         if (hasSameMembers) {
-            await registerMessageInRoom(this.messageId, roomId, this.isSeen, this.envelope.date);
+            await registerMessageInRoom(this.messageId, roomId, this.envelope.date);
+            await this.incrementNotSeen(roomId);
         } else {
             await this.initiateThread();
         }
@@ -142,21 +157,21 @@ export default class RegisterMessageInApp {
                     // create or add new message to DM
                     if (!this.envelope.to) throw new Error("Who send a DM and put the recipient in cc ?");
                     const userTo = await getAddresseId(createAddress(this.envelope.to[0]));
-                    await this.createOrRegisterOnExistence(userTo, roomType.DM);
+                    await this.createOrRegisterOnExistence(userTo, RoomType.DM);
                 } else {
                     // it is not a reply and not a dm
                     // so it is a channel, which can be possibly a group
-                    this.initiateRoom(this.ownerId, roomType.ROOM);
+                    this.initiateRoom(this.ownerId, RoomType.ROOM);
                 }
             } else {
-                await this.createOrRegisterOnExistence(this.ownerId, roomType.ROOM);
+                await this.createOrRegisterOnExistence(this.ownerId, RoomType.ROOM);
             }
         }
     }
 
     async saveReply() {
         await findRoomsFromMessage(this.inReplyTo).then(async (rooms) => {
-            if (rooms.length == 0) {
+            if (rooms.length < 1) {
                 // no rooms, so is a transfer
                 // todo test if members of transferred message are included
             } else if (rooms.length === 1) {

back/test/mail/saveMessage-test.ts

@@ -1,18 +1,56 @@
-import mysql from "mysql";
-
 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 registerMessageInApp, { roomType } from "../../mails/saveMessage";
 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 {
+        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 } from "../../db/utils/mail";
+import {
+    createRoom,
+    registerMessageInRoom,
+    isRoomGroup,
+    findRoomsFromMessage,
+    hasSameMembersAsParent,
+    registerThread,
+    registerMember,
+    getAllMembers,
+    getThreadInfo,
+    incrementNotSeenRoom,
+} from "../../db/saveMessage-db";
 // todo esbuild
-// todo mock db
 // new message from us
 //     to multiple people -> room
 //         if response has same member => group
@@ -27,36 +65,35 @@ import { getAddresseId, getUserIdOfMailbox } from "../../db/utils/mail";
 //         // make it better
 //         if multiple members reply -> group
 //         if only me reply -> channel
-const users = generateUsers(5);
-const ownUser = users[0];
-const messageId = 1;
-const boxId = 1;
-
-jest.mock("../../db/utils/mail", () => ({
-    getAddresseId: jest.fn().mockImplementation((email) => {
-        const match = users.find((user) => user.user.mailbox + "@" + user.user.host == email);
-        return new Promise((resolve, reject) => resolve(match?.id));
-    }),
-    getUserIdOfMailbox: jest.fn().mockImplementation((boxId) => {
-        return new Promise((resolve, reject) => resolve([{ user_id: ownUser.id }]));
-    }),
-}));
 
 beforeAll(async () => {
+    db.clear();
+    mocked(getAddresseId).mockImplementation(db.getAddresseId);
+    mocked(getUserIdOfMailbox).mockImplementation(db.getUserIdOfMailbox);
 
+    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);
 });
 
 describe("saveMessage", () => {
     describe("functions", () => {
         it("isFromUs", async () => {
-            const attrs = generateAttrs({ from: [ownUser.user], to: [users[1].user] });
+            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: [users[2].user], to: [users[1].user] });
+            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();
@@ -66,57 +103,77 @@ describe("saveMessage", () => {
     });
     describe("implementation", () => {
         describe("new first message from us", () => {
-            it("new first message from us to one recipient should create a DM", async () => {
+            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: [users[1].user] });
+                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: number) => new Promise((resolve, reject) => resolve()),
+                        (owner: number, roomType: RoomType) => new Promise((resolve, reject) => resolve()),
                     );
 
                 await register.save();
 
-                expect(createOrRegisterOnExistence).toHaveBeenCalledWith(users[1].id, roomType.DM);
+                expect(createOrRegisterOnExistence).toHaveBeenCalledWith(db.users[1].id, RoomType.DM);
             });
-            it("new first message from us to multiple recipients should create a ROOM", async () => {
+            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: [users[1].user, users[2].user] });
+                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: number) => Promise.resolve(1));
+                    .mockImplementation((owner: number, roomType: RoomType) => Promise.resolve(1));
 
                 await register.save();
 
-                expect(initiateRoom).toHaveBeenCalledWith(ownUser.id, roomType.ROOM);
+                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 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("response to new first message to multiple recipients with different members should change room type to CHANNEL", () => {
+
+            // });
         });
         describe("new first message from other", () => {
-            it("new first message from other to me only should create a room", async () => {
+            it("should create a ROOM when there is a new first message from other to me only", async () => {
-                const attrs = generateAttrs({ from: [users[1].user], to: [ownUser.user] });
+                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: number) => {
+                    .mockImplementation((owner: number, roomType: RoomType) => {
                         return new Promise((resolve, reject) => resolve());
                     });
 
                 await register.save();
 
-                expect(createOrRegisterOnExistence).toHaveBeenCalledWith(users[1].id, roomType.ROOM);
+                expect(createOrRegisterOnExistence).toHaveBeenCalledWith(db.users[1].id, RoomType.ROOM);
             });
         });
-        // describe("replies", () => {
+        describe("replies", () => {
-        //     it("", () => {});
+            it("", () => {});
-        // });
+        });
-        // describe("", () => {});
+    });
+    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", () => {
+            
+        });
     });
 });

back/test/test-utils/db/test-saveMessage.ts

@@ -0,0 +1,152 @@
+import { AttrsWithEnvelope, User } from "../../../interfaces/mail/attrs.interface";
+import { RoomType } from "../../../mails/saveMessage";
+import { getMembers } from "../../../mails/utils/envelopeUtils";
+import { hasSameElements } from "../../../utils/array";
+import { generateUsers, UserTest } from "../test-attrsUtils";
+
+interface Room {
+    room_id: number;
+    room_name: string;
+    owner_id: number;
+    message_id: number;
+    room_type: RoomType;
+    notSeen: number;
+    lastUpdate: string;
+    members?: UserTest[];
+    is_thread?: boolean;
+    parent_id?: number;
+    root_id?: number;
+}
+
+export default class saveMessageDatabase {
+    rooms: Room[];
+    roomId: number;
+    messages: {attrs: AttrsWithEnvelope, message_id: number}[];
+    room_message: {room_id: number, message_id: number}[];
+    users: UserTest[];
+
+    constructor(_users) {
+        this.rooms = [];
+        this.messages = [];
+        this.room_message = [];
+        this.users = generateUsers(5); // todo
+        this.roomId = 0;
+    }
+
+    clear() {
+        this.rooms = [];
+        this.messages = [];
+        this.roomId = 0;
+    }
+
+    _findRoomById(roomId: number): Room {
+        return this.rooms.find((room) => room.room_id === roomId);
+    }
+
+    _findUserByMailbox(mailbox: string): UserTest {
+        return this.users.find((user) => user.user.mailbox === mailbox);
+    }
+
+    createRoom = (
+        roomName: string | null | undefined,
+        ownerId: number,
+        messageId: number,
+        roomType: RoomType,
+    ): Promise<number> => {
+        this.rooms.push({
+            room_id: this.roomId,
+            room_name: roomName,
+            owner_id: ownerId,
+            message_id: messageId,
+            room_type: roomType,
+            notSeen: 0,
+            lastUpdate: "0",
+        });
+        this.roomId++;
+        return Promise.resolve(this.roomId - 1);
+    };
+
+    registerMessageInRoom = (messageId: number, roomId: number, idate: string | undefined | null): Promise<void> => {
+        this.room_message.push({ message_id: messageId, room_id: roomId });
+        return Promise.resolve();
+    };
+
+    isRoomGroup(roomId: number): Promise<boolean> {
+        return new Promise((resolve, reject) => {
+            resolve(this.rooms.find((room) => room.room_id == roomId).room_type === RoomType.GROUP);
+        });
+    }
+
+    findRoomsFromMessage = (messageID: string): Promise<{ room_id: number }[]> => {
+        return new Promise((resolve, reject) => {
+            const rooms = this.rooms.filter((room) => room.message_id.toString() === messageID);
+            const res: { room_id: number }[] = [];
+            rooms.forEach((room) => {
+                res.push({ room_id: room.room_id });
+            });
+            resolve(res);
+        });
+    };
+
+    hasSameMembersAsParent(messageId: number, messageID: string): Promise<boolean> {
+        const msg1 = this.messages.find((message) => message.attrs.envelope.messageId === messageID );
+        const msg2 = this.messages.find((message) => message.message_id === messageId );
+        const members1 = getMembers(msg1.attrs.envelope);
+        const members2 = getMembers(msg2.attrs.envelope);
+        let ids1 = [];
+        let ids2 = [];
+        members1.forEach((member) => ids1.push(this._findUserByMailbox(member.mailbox).id));
+        members2.forEach((member) => ids2.push(this._findUserByMailbox(member.mailbox).id));
+        return Promise.resolve(hasSameElements(ids1, ids2));
+    }
+
+    registerThread = async (roomId: number, parentId: number, rootId: number) => {
+        const room = this._findRoomById(roomId);
+        room.parent_id = parentId;
+        room.room_id = rootId;
+    };
+
+    registerMember(roomId: number, memberId: number): Promise<any> {
+        const room = this._findRoomById(roomId);
+        room.members.push(this.users.find((user) => user.id === memberId));
+        return Promise.resolve(true);
+    }
+
+    getAllMembers(messageId: number): Promise<any> {
+        // test_todo
+        return Promise.resolve(true);
+    }
+
+    getThreadInfo = (messageID: string): Promise<{ room_id: number; root_id: number }[]> => {
+        return new Promise((resolve, reject) => {
+            const room = this.rooms.find((room) => room.message_id.toString() === messageID);
+            resolve([{ room_id: room.room_id, root_id: room.root_id }]);
+        });
+    };
+
+    incrementNotSeenRoom = (roomId: number): Promise<void> => {
+        const room = this._findRoomById(roomId);
+        room.notSeen++;
+        return Promise.resolve();
+    };
+
+    findRoomByOwner = (ownerId: number): Promise<{ room_id: number }[]> => {
+        return new Promise((resolve, reject) => {
+            const rooms = this.rooms.filter((room) => room.owner_id === ownerId);
+            const res = [];
+            rooms.forEach((room) => {
+                res.push({ room_id: room.room_id });
+            });
+            resolve(res);
+        });
+    };
+
+    getAddresseId = (email: string, name?: string): Promise<number> => {
+        const match = this.users.find((user) => user.user.mailbox + "@" + user.user.host == email);
+        return new Promise((resolve, reject) => resolve(match?.id));
+    };
+
+    getUserIdOfMailbox = (boxId: number): Promise<{ user_id: number }[]> => {
+        return new Promise((resolve, rejects) => resolve([{ user_id: this.users[0].id }]));
+    };
+}

back/test/test-utils/test-attrsUtils.ts

@@ -40,7 +40,12 @@ export function generateAttrs(options: Options): AttrsWithEnvelope {
     return attrs;
 }
 
-export function generateUsers(nb: number) {
+export interface UserTest {
+    user: User;
+    id: number;
+}
+
+export function generateUsers(nb: number): UserTest[] {
     const users: {user: User, id: number}[] = [];
     for (let i = 0; i < nb; i++) {
         users.push({

back/utils/array.ts

@@ -7,3 +7,10 @@ export function removeDuplicates(array: []) {
     }
     return unique;
 }
+
+export function hasSameElements(a1: any[], a2: any[]) {
+    return (
+        a1.length == a2.length &&
+        a1.reduce((a, b) => a && a2.includes(b), true)
+    );
+}