@flashphoner/sfusdk 1.0.47 → 2.0.48

package/src/tests/sdk/sfu-extended.test.js

@@ -1,265 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const sfu = require("../../sdk/sfu-extended");
-const constants = require("../../sdk/constants");
-
-const SERVER = "ws://127.0.0.1:8080";
-const USER = "bob@flashphoner.com";
-const PASSWD = "123456";
-const CHAT_ID = "test-chat-id";
-const CHANNEL_ID = "test-channel-id";
-const CHANNEL_NAME = "test-channel";
-const CHAT_NAME = "test-chat";
-const CHAT_NAME2 = "test-chat2";
-const USER2 = "alice@flashphoner.com";
-const MESSAGE_BODY = "This is a test message";
-const MEMBERS = [
-    "bob@flashphoner.com",
-    "alice@flashphoner.com",
-    "kiri@flashphoner.com"
-];
-const FILE = "../assets/1.jpeg";
-
-jest.isolateModules(() => {
-    sfu2 = require("../../sdk/sfu-extended");
-});
-
-beforeAll( async () => {
-    await sfu.connect({
-        url: SERVER,
-        username: USER,
-        password: PASSWD
-    });
-    const chats = await sfu.getUserChats();
-    if (chats) {
-        Object.entries(chats).map(async ([key, value]) => {
-            await sfu.deleteChat({id: value.id});
-        });
-    }
-    await sfu2.connect({
-        url: SERVER,
-        username: USER2,
-        password: PASSWD
-    });
-});
-
-afterAll(async () => {
-    await sfu.disconnect();
-    await sfu2.disconnect();
-});
-
-
-describe("connection", () => {
-    test("should connect to server", () => {
-        expect(sfu.state()).toBe(constants.SFU_STATE.AUTHENTICATED);
-    });
-});
-
-describe("contacts", () => {
-    test("should load user list", () => {
-        return sfu.getUserList();
-    });
-});
-
-describe("calendar", () => {
-    test("should load calendar", () => {
-        return sfu.getUserCalendar().then((calendar) => {
-            expect(calendar).toHaveProperty("events");
-        })
-    })
-});
-
-describe("chat", () => {
-    test("should create new chat", () => {
-        return sfu.createChat({
-            id: CHAT_ID,
-            name: CHAT_NAME
-        });
-    });
-    describe("channels", () => {
-        test("should create new channel", () => {
-            return sfu.createChat({
-                id: CHANNEL_ID,
-                name: CHANNEL_NAME,
-                members: [USER2],
-                channel: true,
-                channelType: "PUBLIC",
-                channelSendPolicy: "ADMIN_AND_LIST",
-                sendPermissionList: [USER2]
-            });
-        });
-        test("should load public channels", async () => {
-            const channels = await sfu.getPublicChannels();
-            expect(channels).toBeTruthy();
-            expect(channels).toHaveProperty(CHANNEL_ID);
-        });
-        test("channel should appear in loaded chats", async () => {
-            const chats = await sfu.getUserChats();
-            expect(chats).toBeTruthy();
-            expect(chats).toHaveProperty(CHANNEL_ID);
-        });
-        test("should load channel", async () => {
-            const chat = await sfu.loadChat({id: CHANNEL_ID});
-            expect(chat.id).toBe(CHANNEL_ID);
-            expect(chat.name).toBe(CHANNEL_NAME);
-            expect(chat.members).toContain(USER);
-            expect(chat.channel).toBe(true);
-        });
-    });
-    test("should load chats", () => {
-        return sfu.getUserChats().then((chats) => {
-            expect(chats).toBeTruthy();
-        });
-    });
-    test("should add new member", () => {
-        return sfu.addMemberToChat({
-            id: CHAT_ID,
-            member: USER2
-        });
-    });
-    test("should send a message", () => {
-        return sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY
-        });
-    });
-    test("should send message with attachment", () => {
-        const file = fs.readFileSync(path.resolve(__dirname, FILE));
-        let byteArray = new Uint8Array(file);
-        let base64Content = Buffer.from(byteArray).toString('base64');
-        return sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY,
-            attachments: [
-                {
-                    type: "file",
-                    name: FILE,
-                    payload: base64Content,
-                    size: byteArray.length
-                }
-            ]
-        });
-    });
-    test("should mark message as read", async () => {
-        const msg = await sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY
-        });
-        const freshState = await sfu.markMessageRead(msg);
-        expect(freshState.lastReadMessageId).toBeTruthy();
-        expect(freshState).toBeTruthy();
-    });
-    test("should mark message as unread", async () => {
-        const msg1 = await sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY
-        });
-        const msg2 = await sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY
-        });
-        const freshState = await sfu.markMessageUnread(msg2);
-        expect(freshState).toBeTruthy();
-        expect(freshState.lastReadMessageId).toBeTruthy();
-        expect(freshState.lastReadMessageId).toEqual(msg1.id);
-    });
-    test("should load chat", () => {
-        return sfu.loadChat({
-            id: CHAT_ID
-        }).then((chat) => {
-            expect(chat.id).toBe(CHAT_ID);
-            expect(chat.name).toBe(CHAT_NAME);
-            expect(chat.members).toContain(USER);
-            expect(Array.isArray(chat.messages)).toBe(true);
-            expect(chat.messages.length).toBeGreaterThan(0);
-        });
-    });
-    test("should remove member", () => {
-        return sfu.removeMemberFromChat({
-            id: CHAT_ID,
-            member: USER2
-        });
-    });
-    test("should rename chat", () => {
-        return sfu.renameChat({
-            id: CHAT_ID,
-            name: CHAT_NAME2
-        });
-    });
-    test("should invite contact", async () => {
-        const contact = await sfu.inviteContact({
-            to: USER2
-        });
-        expect(contact).toBeTruthy();
-        expect(contact.invite).toBeTruthy();
-        expect(contact.invite.id).toBeTruthy();
-    });
-    test("should confirm invite", async () => {
-        const contacts = await sfu2.getUserList();
-        let unconfirmedContact;
-        contacts.every((contact) => {
-            if (contact.invite && contact.invite.from !== USER2) {
-                unconfirmedContact = contact;
-                return false;
-            }
-            return true;
-        });
-        expect(unconfirmedContact).toBeTruthy();
-        const contact = await sfu2.confirmContact(unconfirmedContact.invite);
-        expect(contact).toBeTruthy();
-        expect(contact.confirmed).toEqual(true);
-    });
-    test("should remove contact", async () => {
-        const contact = await sfu.removeContact({
-            id: USER2
-        });
-        expect(contact).toBeTruthy();
-    });
-    test.skip("should receive message", (done) => {
-        sfu.on(constants.SFU_EVENT.MESSAGE, (msg) => {
-            done();
-        })
-        sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY
-        });
-    });
-    test("should receive ACK message", async () => {
-        const msg = await sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY
-        });
-        expect(msg).toBeTruthy();
-        expect(msg.id).toBeTruthy();
-        expect(msg.date).toBeTruthy();
-    });
-    test("should create new chat without id", () => {
-        return sfu.createChat({
-            name: CHAT_NAME
-        });
-    });
-    test("should create new chat with member list", () => {
-        return sfu.createChat({
-            name: CHAT_NAME,
-            members: MEMBERS
-        });
-    });
-    test("should create new chat without name based on members", async () => {
-        const chat = await sfu.createChat({
-            members: MEMBERS
-        });
-        expect(chat.name).toBeTruthy();
-    });
-    test("should delete chat", () => {
-        return sfu.deleteChat({
-            id: CHAT_ID
-        });
-    });
-    test("should change name after member was added", async () => {
-        const chat = await sfu.createChat({});
-        expect(chat.name).toBeTruthy();
-        const name1 = chat.name;
-        const sameChat = await sfu.addMemberToChat({id: chat.id, member: USER2});
-        expect(sameChat.name !== name1).toBeTruthy();
-    });
-});

package/src/tests/sdk/sfu-extended.test.js_

@@ -1,265 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-const sfu = require("../../sdk/sfu-extended");
-const constants = require("../../sdk/constants");
-
-const SERVER = "ws://127.0.0.1:8080";
-const USER = "bob@flashphoner.com";
-const PASSWD = "123456";
-const CHAT_ID = "test-chat-id";
-const CHANNEL_ID = "test-channel-id";
-const CHANNEL_NAME = "test-channel";
-const CHAT_NAME = "test-chat";
-const CHAT_NAME2 = "test-chat2";
-const USER2 = "alice@flashphoner.com";
-const MESSAGE_BODY = "This is a test message";
-const MEMBERS = [
-    "bob@flashphoner.com",
-    "alice@flashphoner.com",
-    "kiri@flashphoner.com"
-];
-const FILE = "../assets/1.jpeg";
-
-jest.isolateModules(() => {
-    sfu2 = require("../../sdk/sfu-extended");
-});
-
-beforeAll( async () => {
-    await sfu.connect({
-        url: SERVER,
-        username: USER,
-        password: PASSWD
-    });
-    const chats = await sfu.getUserChats();
-    if (chats) {
-        Object.entries(chats).map(async ([key, value]) => {
-            await sfu.deleteChat({id: value.id});
-        });
-    }
-    await sfu2.connect({
-        url: SERVER,
-        username: USER2,
-        password: PASSWD
-    });
-});
-
-afterAll(async () => {
-    await sfu.disconnect();
-    await sfu2.disconnect();
-});
-
-
-describe("connection", () => {
-    test("should connect to server", () => {
-        expect(sfu.state()).toBe(constants.SFU_STATE.AUTHENTICATED);
-    });
-});
-
-describe("contacts", () => {
-    test("should load user list", () => {
-        return sfu.getUserList();
-    });
-});
-
-describe("calendar", () => {
-    test("should load calendar", () => {
-        return sfu.getUserCalendar().then((calendar) => {
-            expect(calendar).toHaveProperty("events");
-        })
-    })
-});
-
-describe("chat", () => {
-    test("should create new chat", () => {
-        return sfu.createChat({
-            id: CHAT_ID,
-            name: CHAT_NAME
-        });
-    });
-    describe("channels", () => {
-        test("should create new channel", () => {
-            return sfu.createChat({
-                id: CHANNEL_ID,
-                name: CHANNEL_NAME,
-                members: [USER2],
-                channel: true,
-                channelType: "PUBLIC",
-                channelSendPolicy: "ADMIN_AND_LIST",
-                sendPermissionList: [USER2]
-            });
-        });
-        test("should load public channels", async () => {
-            const channels = await sfu.getPublicChannels();
-            expect(channels).toBeTruthy();
-            expect(channels).toHaveProperty(CHANNEL_ID);
-        });
-        test("channel should appear in loaded chats", async () => {
-            const chats = await sfu.getUserChats();
-            expect(chats).toBeTruthy();
-            expect(chats).toHaveProperty(CHANNEL_ID);
-        });
-        test("should load channel", async () => {
-            const chat = await sfu.loadChat({id: CHANNEL_ID});
-            expect(chat.id).toBe(CHANNEL_ID);
-            expect(chat.name).toBe(CHANNEL_NAME);
-            expect(chat.members).toContain(USER);
-            expect(chat.channel).toBe(true);
-        });
-    });
-    test("should load chats", () => {
-        return sfu.getUserChats().then((chats) => {
-            expect(chats).toBeTruthy();
-        });
-    });
-    test("should add new member", () => {
-        return sfu.addMemberToChat({
-            id: CHAT_ID,
-            member: USER2
-        });
-    });
-    test("should send a message", () => {
-        return sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY
-        });
-    });
-    test("should send message with attachment", () => {
-        const file = fs.readFileSync(path.resolve(__dirname, FILE));
-        let byteArray = new Uint8Array(file);
-        let base64Content = Buffer.from(byteArray).toString('base64');
-        return sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY,
-            attachments: [
-                {
-                    type: "file",
-                    name: FILE,
-                    payload: base64Content,
-                    size: byteArray.length
-                }
-            ]
-        });
-    });
-    test("should mark message as read", async () => {
-        const msg = await sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY
-        });
-        const freshState = await sfu.markMessageRead(msg);
-        expect(freshState.lastReadMessageId).toBeTruthy();
-        expect(freshState).toBeTruthy();
-    });
-    test("should mark message as unread", async () => {
-        const msg1 = await sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY
-        });
-        const msg2 = await sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY
-        });
-        const freshState = await sfu.markMessageUnread(msg2);
-        expect(freshState).toBeTruthy();
-        expect(freshState.lastReadMessageId).toBeTruthy();
-        expect(freshState.lastReadMessageId).toEqual(msg1.id);
-    });
-    test("should load chat", () => {
-        return sfu.loadChat({
-            id: CHAT_ID
-        }).then((chat) => {
-            expect(chat.id).toBe(CHAT_ID);
-            expect(chat.name).toBe(CHAT_NAME);
-            expect(chat.members).toContain(USER);
-            expect(Array.isArray(chat.messages)).toBe(true);
-            expect(chat.messages.length).toBeGreaterThan(0);
-        });
-    });
-    test("should remove member", () => {
-        return sfu.removeMemberFromChat({
-            id: CHAT_ID,
-            member: USER2
-        });
-    });
-    test("should rename chat", () => {
-        return sfu.renameChat({
-            id: CHAT_ID,
-            name: CHAT_NAME2
-        });
-    });
-    test("should invite contact", async () => {
-        const contact = await sfu.inviteContact({
-            to: USER2
-        });
-        expect(contact).toBeTruthy();
-        expect(contact.invite).toBeTruthy();
-        expect(contact.invite.id).toBeTruthy();
-    });
-    test("should confirm invite", async () => {
-        const contacts = await sfu2.getUserList();
-        let unconfirmedContact;
-        contacts.every((contact) => {
-            if (contact.invite && contact.invite.from !== USER2) {
-                unconfirmedContact = contact;
-                return false;
-            }
-            return true;
-        });
-        expect(unconfirmedContact).toBeTruthy();
-        const contact = await sfu2.confirmContact(unconfirmedContact.invite);
-        expect(contact).toBeTruthy();
-        expect(contact.confirmed).toEqual(true);
-    });
-    test("should remove contact", async () => {
-        const contact = await sfu.removeContact({
-            id: USER2
-        });
-        expect(contact).toBeTruthy();
-    });
-    test.skip("should receive message", (done) => {
-        sfu.on(constants.SFU_EVENT.MESSAGE, (msg) => {
-            done();
-        })
-        sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY
-        });
-    });
-    test("should receive ACK message", async () => {
-        const msg = await sfu.sendMessage({
-            chatId: CHAT_ID,
-            body: MESSAGE_BODY
-        });
-        expect(msg).toBeTruthy();
-        expect(msg.id).toBeTruthy();
-        expect(msg.date).toBeTruthy();
-    });
-    test("should create new chat without id", () => {
-        return sfu.createChat({
-            name: CHAT_NAME
-        });
-    });
-    test("should create new chat with member list", () => {
-        return sfu.createChat({
-            name: CHAT_NAME,
-            members: MEMBERS
-        });
-    });
-    test("should create new chat without name based on members", async () => {
-        const chat = await sfu.createChat({
-            members: MEMBERS
-        });
-        expect(chat.name).toBeTruthy();
-    });
-    test("should delete chat", () => {
-        return sfu.deleteChat({
-            id: CHAT_ID
-        });
-    });
-    test("should change name after member was added", async () => {
-        const chat = await sfu.createChat({});
-        expect(chat.name).toBeTruthy();
-        const name1 = chat.name;
-        const sameChat = await sfu.addMemberToChat({id: chat.id, member: USER2});
-        expect(sameChat.name !== name1).toBeTruthy();
-    });
-});

package/src/tests/util.js

@@ -1,48 +0,0 @@
-const waitForTrack = (pc, track) => {
-    return new Promise((resolve, reject) => {
-        pc.ontrack = ({transceiver}) => {
-            if (transceiver.mid === track.mid) {
-                resolve(transceiver.receiver.track);
-            }
-        }
-    });
-};
-
-const waitForTracks = (pc, tracks) => {
-    return new Promise((resolve, reject) => {
-        let waitingFor = tracks.length;
-        const trackArrived = () => {
-            waitingFor--;
-            if (waitingFor === 0) {
-                resolve();
-            }
-        };
-        for (const track of tracks) {
-            waitForTrack(pc, track).then(trackArrived);
-        }
-    });
-};
-
-const waitForPeerConnectionStableState = (pc) => {
-    return waitForPeerConnectionState(pc, "stable");
-}
-
-const waitForPeerConnectionState = (pc, state) => {
-    return new Promise((resolve, reject) => {
-        if (pc.signalingState === state) {
-            resolve();
-        }
-        pc.onsignalingstatechange = (e) => {
-            if (pc.signalingState === state) {
-                resolve();
-            }
-        }
-    });
-};
-
-module.exports = {
-    waitForTrack: waitForTrack,
-    waitForTracks: waitForTracks,
-    waitForPeerConnectionState: waitForPeerConnectionState,
-    waitForPeerConnectionStableState: waitForPeerConnectionStableState
-}