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

implement database as a class for tests

Browse Source
This commit is contained in:
grimhilt
2023-04-04 17:13:18 +02:00
parent 9c16e06446
commit 5a71e104cd
5 changed files with 211 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,18 +1,31 @@
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 { generateAttrs, generateUsers } from "../test-utils/test-attrsUtils";
import registerMessageInApp, { roomType } from "../../mails/saveMessage";
import { jest, describe, it, expect } from "@jest/globals";
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));
const ownUser = db.users[0];
const messageId = 1;
const boxId = 1;
jest.mock("../../db/utils/mail", () => {
return {
getAddresseId: jest.fn(),
getUserIdOfMailbox: jest.fn(),
};
});
import { getAddresseId, getUserIdOfMailbox } from "../../db/utils/mail";
// todo esbuild
// todo mock db
// new message from us
// to multiple people -> room
// if response has same member => group
@@ -27,36 +40,24 @@ 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);
});
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();
@@ -67,56 +68,56 @@ describe("saveMessage", () => {
describe("implementation", () => {
describe("new first message from us", () => {
it("new first message from us to one recipient should create a DM", 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 () => {
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 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 () => {
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", () => {
// it("", () => {});
// });
// describe("", () => {});
describe("unseen behavior", () => {});
});
});

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

@@ -0,0 +1,123 @@
import { RoomType } from "../../../mails/saveMessage";
import { generateUsers } from "../test-attrsUtils";
interface Room {
room_id: number;
room_name: string;
owner_id: number;
message_id: number;
room_type: RoomType;
notSeen: number;
lastUpdate: string;
is_thread?: boolean;
parent_id?: number;
root_id?: number;
}
export default class saveMessageDatabase {
rooms: Room[];
roomId: number;
messages: { room_id: number; message_id: number }[];
users: any[];
constructor(_users) {
this.rooms = [];
this.messages = [];
this.users = generateUsers(5);
this.roomId = 0;
}
clear() {
this.rooms = [];
this.messages = [];
this.roomId = 0;
}
_findRoomById(roomId: number): Room {
return this.rooms.find((room) => room.room_id === roomId);
}
createRoom(roomName: string | null | undefined, ownerId: number, messageId: number, roomType: RoomType) {
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++;
}
registerMessageInRoom = (messageId: number, roomId: number, idate: string | undefined | null) => {
this.messages.push({ message_id: messageId, room_id: roomId });
};
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() {
// test_todo
}
registerThread = async (roomId: number, parentId: number, rootId: number) => {
const room = this._findRoomById(roomId);
room.parent_id = parentId;
room.room_id = rootId;
};
registerMember() {
// test_todo
}
getAllMembers() {
// test_todo
}
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) => {
const room = this._findRoomById(roomId);
room.notSeen++;
}
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 }]));
};
}