grimhilt/mail
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

advancements in tests

Browse Source
This commit is contained in:
grimhilt 2023-04-04 18:00:27 +02:00
parent 5a71e104cd
commit 9fc31f8686
5 changed files with 132 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
back/db/saveMessage-db.ts
View File

@ -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 (
addressesMsg1.length == addressesMsg2.length &&
addressesMsg1.reduce((a, b) => a && addressesMsg2.includes(b), true)
);
return hasSameElements(addressesMsg1, addressesMsg2);
}

82
back/test/mail/saveMessage-test.ts
View File

@ -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 different members should change room type to CHANNEL", () => {});
// 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", () => {
// });
});
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", () => {
// it("", () => {});
// });
describe("unseen behavior", () => {});
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", () => {
});
});
});

59
back/test/test-utils/db/test-saveMessage.ts
View File

@ -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 }[];
users: any[];
messages: {attrs: AttrsWithEnvelope, message_id: number}[];
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) => {
this.messages.push({ message_id: messageId, room_id: roomId });
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> {
@ -71,8 +88,16 @@ export default class saveMessageDatabase {
});
};
hasSameMembersAsParent() {
// test_todo
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) => {
@ -81,12 +106,15 @@ export default class saveMessageDatabase {
room.room_id = rootId;
};
registerMember() {
// test_todo
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() {
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) => {

7
back/test/test-utils/test-attrsUtils.ts
View File

@ -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({

7
back/utils/array.ts
View File

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