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

thread tests

Browse Source
This commit is contained in:
grimhilt 2023-04-05 12:33:32 +02:00
parent 9fc31f8686
commit 65631f8e9a
3 changed files with 126 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
back/mails/saveMessage.ts
View File

@ -82,6 +82,7 @@ export default class RegisterMessageInApp {
async registerMembers(roomId: number) { async registerMembers(roomId: number) {
getAllMembers(this.messageId).then((res) => { getAllMembers(this.messageId).then((res) => {
if (res.lenght == 0) return;
const data = res[0].id.split(","); const data = res[0].id.split(",");
data.forEach(async (memberId: number) => { data.forEach(async (memberId: number) => {
await registerMember(roomId, memberId); await registerMember(roomId, memberId);
@ -124,8 +125,8 @@ export default class RegisterMessageInApp {
// todo room not lenght, reply to transfer ? // todo room not lenght, reply to transfer ?
roomId = room[0].room_id; roomId = room[0].room_id;
let root_id = room[0].root_id; let root_id = room[0].root_id;
if (!root_id) root_id = roomId; if (root_id === undefined) root_id = roomId;
await registerThread(threadId, room[0].room_id, root_id); await registerThread(threadId, roomId, root_id);
}); });
// impl register previous message or go back // impl register previous message or go back
await registerMessageInRoom(this.messageId, threadId, this.envelope.date); await registerMessageInRoom(this.messageId, threadId, this.envelope.date);
@ -150,7 +151,7 @@ export default class RegisterMessageInApp {
await this.init(); await this.init();
if (this.envelope.inReplyTo) { if (this.envelope.inReplyTo) {
this.inReplyTo = this.envelope.inReplyTo; this.inReplyTo = this.envelope.inReplyTo;
this.saveReply(); await this.saveReply();
} else { } else {
if (await this.isFromUs()) { if (await this.isFromUs()) {
if (this.isDm()) { if (this.isDm()) {
@ -161,7 +162,7 @@ export default class RegisterMessageInApp {
} else { } else {
// it is not a reply and not a dm // it is not a reply and not a dm
// so it is a channel, which can be possibly a group // so it is a channel, which can be possibly a group
this.initiateRoom(this.ownerId, RoomType.ROOM); await this.initiateRoom(this.ownerId, RoomType.ROOM);
} }
} else { } else {
await this.createOrRegisterOnExistence(this.ownerId, RoomType.ROOM); await this.createOrRegisterOnExistence(this.ownerId, RoomType.ROOM);
@ -181,7 +182,8 @@ export default class RegisterMessageInApp {
if (isGroup) { if (isGroup) {
this.createOrRegisterOnMembers(rooms[0].room_id); this.createOrRegisterOnMembers(rooms[0].room_id);
} else { } else {
// reply from channel // reply from CHANNEL or DM or ROOM
await this.initiateThread();
// todo // todo
// if (sender == owner) { // correction from the original sender // if (sender == owner) { // correction from the original sender
// // leave in the same channel // // leave in the same channel
@ -191,7 +193,7 @@ export default class RegisterMessageInApp {
} else if (rooms.length > 1) { } else if (rooms.length > 1) {
// get the lowest thread (order by room_id) // get the lowest thread (order by room_id)
const roomId = rooms[rooms.length - 1].room_id; const roomId = rooms[rooms.length - 1].room_id;
this.createOrRegisterOnMembers(roomId); await this.createOrRegisterOnMembers(roomId);
} }
}); });
} }

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

@ -19,6 +19,7 @@ const boxId = 1;
jest.mock("../../db/utils/mail", () => { jest.mock("../../db/utils/mail", () => {
return { return {
findRoomByOwner: jest.fn(),
getAddresseId: jest.fn(), getAddresseId: jest.fn(),
getUserIdOfMailbox: jest.fn(), getUserIdOfMailbox: jest.fn(),
}; };
@ -37,7 +38,7 @@ jest.mock("../../db/saveMessage-db", () => {
incrementNotSeenRoom: jest.fn(), incrementNotSeenRoom: jest.fn(),
}; };
}); });
import { getAddresseId, getUserIdOfMailbox } from "../../db/utils/mail"; import { getAddresseId, getUserIdOfMailbox, findRoomByOwner } from "../../db/utils/mail";
import { import {
createRoom, createRoom,
registerMessageInRoom, registerMessageInRoom,
@ -50,6 +51,7 @@ import {
getThreadInfo, getThreadInfo,
incrementNotSeenRoom, incrementNotSeenRoom,
} from "../../db/saveMessage-db"; } from "../../db/saveMessage-db";
import { AttrsWithEnvelope } from "../../interfaces/mail/attrs.interface";
// todo esbuild // todo esbuild
// new message from us // new message from us
// to multiple people -> room // to multiple people -> room
@ -67,9 +69,9 @@ import {
// if only me reply -> channel // if only me reply -> channel
beforeAll(async () => { beforeAll(async () => {
db.clear();
mocked(getAddresseId).mockImplementation(db.getAddresseId); mocked(getAddresseId).mockImplementation(db.getAddresseId);
mocked(getUserIdOfMailbox).mockImplementation(db.getUserIdOfMailbox); mocked(getUserIdOfMailbox).mockImplementation(db.getUserIdOfMailbox);
mocked(findRoomByOwner).mockImplementation(db.findRoomByOwner);
mocked(createRoom).mockImplementation(db.createRoom); mocked(createRoom).mockImplementation(db.createRoom);
mocked(registerMessageInRoom).mockImplementation(db.registerMessageInRoom); mocked(registerMessageInRoom).mockImplementation(db.registerMessageInRoom);
@ -83,7 +85,30 @@ beforeAll(async () => {
mocked(incrementNotSeenRoom).mockImplementation(db.incrementNotSeenRoom); 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("saveMessage", () => {
describe("functions", () => { describe("functions", () => {
it("isFromUs", async () => { it("isFromUs", async () => {
const attrs = generateAttrs({ from: [ownUser.user], to: [db.users[1].user] }); const attrs = generateAttrs({ from: [ownUser.user], to: [db.users[1].user] });
@ -101,79 +126,93 @@ describe("saveMessage", () => {
expect(res2).toBe(false); expect(res2).toBe(false);
}); });
}); });
describe("implementation", () => { describe("room creation", () => {
describe("new first message from us", () => { it("should create a DM when there is a new first message from us to one recipient", 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 attrs = generateAttrs({ from: [ownUser.user], to: [db.users[1].user] });
const register = new registerMessageInApp(messageId, attrs, boxId); const register = new registerMessageInApp(messageId, attrs, boxId);
const createOrRegisterOnExistence = jest const createOrRegisterOnExistence = jest
.spyOn(register, "createOrRegisterOnExistence") .spyOn(register, "createOrRegisterOnExistence")
.mockImplementation( .mockImplementation((owner: number, roomType: RoomType) => new Promise((resolve, reject) => resolve()));
(owner: number, roomType: RoomType) => new Promise((resolve, reject) => resolve()),
);
await register.save(); await register.save();
expect(createOrRegisterOnExistence).toHaveBeenCalledWith(db.users[1].id, RoomType.DM); 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", () => {
// });
}); });
describe("new first message from other", () => { it("should create a ROOM when there is a new first message from us to multiple recipients", async () => {
it("should create a ROOM when there is a new first message from other to me only", async () => { const attrs = generateAttrs({ from: [ownUser.user], to: [db.users[1].user, db.users[2].user] });
const attrs = generateAttrs({ from: [db.users[1].user], to: [ownUser.user] });
const register = new registerMessageInApp(messageId, attrs, boxId); const register = new registerMessageInApp(messageId, attrs, boxId);
const createOrRegisterOnExistence = jest const initiateRoom = jest
.spyOn(register, "createOrRegisterOnExistence") .spyOn(register, "initiateRoom")
.mockImplementation((owner: number, roomType: RoomType) => { .mockImplementation((owner: number, roomType: RoomType) => Promise.resolve(1));
return new Promise((resolve, reject) => resolve());
});
await register.save(); await register.save();
expect(createOrRegisterOnExistence).toHaveBeenCalledWith(db.users[1].id, RoomType.ROOM); expect(initiateRoom).toHaveBeenCalledWith(ownUser.id, RoomType.ROOM);
});
}); });
describe("replies", () => { // it("response to new first message to multiple recipients with same members should change room type to GROUP", () => {
it("", () => {});
// });
// 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", () => { describe("unseen behavior", () => {
it("should add unseen in room when a message creates a room", () => { 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 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", () => {});
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", () => {
});
}); });
}); });

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

@ -36,14 +36,15 @@ export default class saveMessageDatabase {
clear() { clear() {
this.rooms = []; this.rooms = [];
this.messages = []; this.messages = [];
this.room_message = [];
this.roomId = 0; this.roomId = 0;
} }
_findRoomById(roomId: number): Room { _findRoomById = (roomId: number): Room => {
return this.rooms.find((room) => room.room_id === roomId); return this.rooms.find((room) => room.room_id === roomId);
} }
_findUserByMailbox(mailbox: string): UserTest { _findUserByMailbox = (mailbox: string): UserTest => {
return this.users.find((user) => user.user.mailbox === mailbox); return this.users.find((user) => user.user.mailbox === mailbox);
} }
@ -71,7 +72,7 @@ export default class saveMessageDatabase {
return Promise.resolve(); return Promise.resolve();
}; };
isRoomGroup(roomId: number): Promise<boolean> { isRoomGroup = (roomId: number): Promise<boolean> => {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
resolve(this.rooms.find((room) => room.room_id == roomId).room_type === RoomType.GROUP); resolve(this.rooms.find((room) => room.room_id == roomId).room_type === RoomType.GROUP);
}); });
@ -88,7 +89,7 @@ export default class saveMessageDatabase {
}); });
}; };
hasSameMembersAsParent(messageId: number, messageID: string): Promise<boolean> { hasSameMembersAsParent = (messageId: number, messageID: string): Promise<boolean> => {
const msg1 = this.messages.find((message) => message.attrs.envelope.messageId === messageID ); const msg1 = this.messages.find((message) => message.attrs.envelope.messageId === messageID );
const msg2 = this.messages.find((message) => message.message_id === messageId ); const msg2 = this.messages.find((message) => message.message_id === messageId );
const members1 = getMembers(msg1.attrs.envelope); const members1 = getMembers(msg1.attrs.envelope);
@ -102,19 +103,26 @@ export default class saveMessageDatabase {
registerThread = async (roomId: number, parentId: number, rootId: number) => { registerThread = async (roomId: number, parentId: number, rootId: number) => {
const room = this._findRoomById(roomId); const room = this._findRoomById(roomId);
room.is_thread = true;
room.parent_id = parentId; room.parent_id = parentId;
room.room_id = rootId; room.root_id = rootId;
}; };
registerMember(roomId: number, memberId: number): Promise<any> { registerMember = (roomId: number, memberId: number): Promise<any> => {
const room = this._findRoomById(roomId); const room = this._findRoomById(roomId);
room.members.push(this.users.find((user) => user.id === memberId)); if (!room.members) room.members = [];
room.members.push(this.users.find((user) => user.id == memberId));
return Promise.resolve(true); return Promise.resolve(true);
} }
getAllMembers(messageId: number): Promise<any> { getAllMembers = (messageId: number): Promise<any> => {
// test_todo const message = this.messages.find((message) => message.message_id === messageId);
return Promise.resolve(true); let res = "";
getMembers(message.attrs.envelope).forEach((member) => {
res += this.users.find((user) => user.user.mailbox === member.mailbox).id + ",";
});
res = res.substring(0, res.length-1);
return Promise.resolve([{id: res}]);
} }
getThreadInfo = (messageID: string): Promise<{ room_id: number; root_id: number }[]> => { getThreadInfo = (messageID: string): Promise<{ room_id: number; root_id: number }[]> => {
@ -126,7 +134,7 @@ export default class saveMessageDatabase {
incrementNotSeenRoom = (roomId: number): Promise<void> => { incrementNotSeenRoom = (roomId: number): Promise<void> => {
const room = this._findRoomById(roomId); const room = this._findRoomById(roomId);
room.notSeen++; if (room) room.notSeen++; // todo
return Promise.resolve(); return Promise.resolve();
}; };