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 (?, ?, ?, ?)`;
@@ -97,7 +99,7 @@ export async function findRoomsFromMessage(messageID: string): Promise<{ room_id
     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,
@@ -135,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/test/mail/saveMessage-test.ts

@@ -6,25 +6,50 @@ mysql.createConnection.mockImplementation(() => {
 });
 
 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";
 
-const db = new saveMessageDatabase(generateUsers(5));
+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
 // new message from us
 //     to multiple people -> room
@@ -45,6 +70,17 @@ 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", () => {
@@ -67,7 +103,7 @@ 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: [db.users[1].user] });
 
                 const register = new registerMessageInApp(messageId, attrs, boxId);
@@ -82,7 +118,7 @@ describe("saveMessage", () => {
 
                 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: [db.users[1].user, db.users[2].user] });
 
                 const register = new registerMessageInApp(messageId, attrs, boxId);
@@ -95,11 +131,15 @@ describe("saveMessage", () => {
 
                 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: [db.users[1].user], to: [ownUser.user] });
 
                 const register = new registerMessageInApp(messageId, attrs, boxId);
@@ -115,9 +155,25 @@ describe("saveMessage", () => {
                 expect(createOrRegisterOnExistence).toHaveBeenCalledWith(db.users[1].id, RoomType.ROOM);
             });
         });
-        // describe("replies", () => {
+        describe("replies", () => {
-        //     it("", () => {});
+            it("", () => {});
-        // });
+        });
-        describe("unseen behavior", () => {});
+    });
+    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

@@ -1,5 +1,8 @@
+import { AttrsWithEnvelope, User } from "../../../interfaces/mail/attrs.interface";
 import { RoomType } from "../../../mails/saveMessage";
-import { generateUsers } from "../test-attrsUtils";
+import { getMembers } from "../../../mails/utils/envelopeUtils";
+import { hasSameElements } from "../../../utils/array";
+import { generateUsers, UserTest } from "../test-attrsUtils";
 
 interface Room {
     room_id: number;
@@ -9,6 +12,7 @@ interface Room {
     room_type: RoomType;
     notSeen: number;
     lastUpdate: string;
+    members?: UserTest[];
     is_thread?: boolean;
     parent_id?: number;
     root_id?: number;
@@ -17,13 +21,15 @@ interface Room {
 export default class saveMessageDatabase {
     rooms: Room[];
     roomId: number;
-    messages: { room_id: number; message_id: number }[];
+    messages: {attrs: AttrsWithEnvelope, message_id: number}[];
-    users: any[];
+    room_message: {room_id: number, message_id: number}[];
+    users: UserTest[];
 
     constructor(_users) {
         this.rooms = [];
         this.messages = [];
-        this.users = generateUsers(5);
+        this.room_message = [];
+        this.users = generateUsers(5); // todo
         this.roomId = 0;
     }
 
@@ -37,7 +43,16 @@ export default class saveMessageDatabase {
         return this.rooms.find((room) => room.room_id === roomId);
     }
 
-    createRoom(roomName: string | null | undefined, ownerId: number, messageId: number, roomType: RoomType) {
+    _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,
@@ -48,10 +63,12 @@ export default class saveMessageDatabase {
             lastUpdate: "0",
         });
         this.roomId++;
-    }
+        return Promise.resolve(this.roomId - 1);
+    };
 
-    registerMessageInRoom = (messageId: number, roomId: number, idate: string | undefined | null) => {
+    registerMessageInRoom = (messageId: number, roomId: number, idate: string | undefined | null): Promise<void> => {
-        this.messages.push({ message_id: messageId, room_id: roomId });
+        this.room_message.push({ message_id: messageId, room_id: roomId });
+        return Promise.resolve();
     };
 
     isRoomGroup(roomId: number): Promise<boolean> {
@@ -71,8 +88,16 @@ export default class saveMessageDatabase {
         });
     };
 
-    hasSameMembersAsParent() {
+    hasSameMembersAsParent(messageId: number, messageID: string): Promise<boolean> {
-        // test_todo
+        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) => {
@@ -81,12 +106,15 @@ export default class saveMessageDatabase {
         room.room_id = rootId;
     };
 
-    registerMember() {
+    registerMember(roomId: number, memberId: number): Promise<any> {
-        // test_todo
+        const room = this._findRoomById(roomId);
+        room.members.push(this.users.find((user) => user.id === memberId));
+        return Promise.resolve(true);
     }
 
-    getAllMembers() {
+    getAllMembers(messageId: number): Promise<any> {
         // test_todo
+        return Promise.resolve(true);
     }
 
     getThreadInfo = (messageID: string): Promise<{ room_id: number; root_id: number }[]> => {
@@ -96,10 +124,11 @@ export default class saveMessageDatabase {
         });
     };
 
-    incrementNotSeenRoom = (roomId: number) => {
+    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) => {

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)
+    );
+}