@flashphoner/sfusdk 1.0.40 → 1.0.47

package/src/tests/sdk/room.test.js

@@ -0,0 +1,229 @@
+const wrtc = require("wrtc");
+const RTCAudioSourceSineWave = require("../lib/rtcaudiosourcesinewave");
+const RTCVideoSourceWrapper = require("../lib/rtcvideosourcewrapper");
+const sfu = require("../../sdk/sfu-extended");
+const constants = require("../../sdk/constants");
+const {waitForTracks, waitForPeerConnectionStableState, waitForPeerConnectionState} = require("../util");
+
+// Jest default timeout
+const JEST_TIMEOUT = 20000;
+
+const SERVER = "ws://127.0.0.1:8080";
+const USER_BOB = "bob@flashphoner.com";
+const BOB_NICKNAME = "bob";
+const USER_ALICE = "alice@flashphoner.com";
+const ALICE_NICKNAME = "alice";
+const PASSWD = "123456";
+
+const ROOM_NAME = "TEST_ROOM";
+const PIN = "1234";
+const USE_WAITING_ROOM = true;
+
+let sfu2;
+
+jest.setTimeout(JEST_TIMEOUT);
+jest.isolateModules(() => {
+    sfu2 = require("../../sdk/sfu-extended");
+});
+
+function stopAfterTimeout(done) {
+    console.log("Test ended");
+    setTimeout(done, 5000);
+}
+
+beforeAll(async () => {
+    await sfu.connect({
+        url: SERVER,
+        username: USER_BOB,
+        password: PASSWD
+    });
+    await sfu2.connect({
+        url: SERVER,
+        username: USER_ALICE,
+        password: PASSWD
+    });
+});
+
+afterAll(async () => {
+    await sfu2.disconnect();
+    await sfu.disconnect();
+});
+
+describe("room", () => {
+    it("should create new room", async () => {
+        const room = sfu.room({
+            name: ROOM_NAME,
+            pin: PIN,
+            pc: new wrtc.RTCPeerConnection()
+        });
+        const ret = await room.createRoom();
+        expect(ret).toBeTruthy();
+    });
+
+    it("should join the room", async () => {
+        const room = sfu.getRoom({name: ROOM_NAME});
+        const ret = await room.join();
+        expect(ret).toBeTruthy();
+        await waitForPeerConnectionStableState(room.pc());
+    });
+
+    it("should configure waiting room", async () => {
+        const room = sfu.getRoom({name: ROOM_NAME});
+        await room.configureWaitingRoom(USE_WAITING_ROOM);
+    })
+
+    describe("second participant", () => {
+        it("should be successfully authorized and joined to the room", async (done) => {
+            console.log("should be successfully authorized and joined to the room");
+            const room = sfu.getRoom({name: ROOM_NAME});
+            const waitingListHandler = async (event) => {
+                if (event.users && event.users.length !== 0) {
+                    const users = event.users;
+                    for (const waitingUser of users) {
+                        const info = await room.subscribeToWaitingParticipant(waitingUser.nickname);
+                        expect(info).toBeTruthy();
+                        expect(Array.isArray(info.info)).toBeTruthy();
+                        expect(info.info.length).toEqual(1);
+                        await waitForTracks(room.pc(), info.info);
+                        await room.unsubscribeFromWaitingParticipant(waitingUser.nickname);
+                        await room.authorizeWaitingList(waitingUser.id, true);
+                        await waitForPeerConnectionStableState(room.pc());
+                    }
+                    room.off(sfu.constants.SFU_ROOM_EVENT.WAITING_LIST, waitingListHandler);
+                    done();
+                }
+            };
+            room.on(sfu.constants.SFU_ROOM_EVENT.WAITING_LIST, waitingListHandler);
+            const room2 = sfu2.room({
+                name: ROOM_NAME,
+                pin: PIN,
+                pc: new wrtc.RTCPeerConnection()
+            });
+            // Audio track
+            const aSource = new RTCAudioSourceSineWave();
+            const aTrack = aSource.createTrack();
+            const aSender = room2.pc().addTrack(aTrack);
+
+            const ret = await room2.join({});
+            expect(ret).toBeTruthy();
+        });
+
+        it("should set new role for the second participant", async () => {
+            const room = sfu.getRoom({name: ROOM_NAME});
+            await room.assignRole(ALICE_NICKNAME, sfu.constants.SFU_PARTICIPANT_ROLE.ADMIN);
+        });
+
+        it("should be able to send message", async () => {
+            const room = sfu.getRoom({name: ROOM_NAME});
+            await room.sendMessage("should be able to send message");
+        });
+
+        it("should be able to send message more then 16384 characters long", async () => {
+            const messageLength = 20000;
+            const letter = "a";
+            let msg = "";
+            for (let i = 0; i < messageLength; i++) {
+                msg += letter;
+            }
+            const room = sfu.getRoom({name: ROOM_NAME});
+            await room.sendMessage(msg);
+        });
+
+        it("should receive message", async (done) => {
+            const msg = "should receive message";
+            const room = sfu.getRoom({name: ROOM_NAME});
+            const room2 = sfu2.getRoom({name: ROOM_NAME});
+            const messageHandler = (message) => {
+                expect(message).toBeTruthy();
+                expect(message.message).toEqual(msg);
+                room2.off(sfu.constants.SFU_ROOM_EVENT.MESSAGE, messageHandler);
+                done();
+            }
+            room2.on(sfu.constants.SFU_ROOM_EVENT.MESSAGE, messageHandler);
+            room.sendMessage(msg);
+        });
+
+        it("should receive message more then 16384 characters long", async (done) => {
+            const messageLength = 20000;
+            const letter = "a";
+            let msg = "";
+            for (let i = 0; i < messageLength; i++) {
+                msg += letter;
+            }
+            const room = sfu.getRoom({name: ROOM_NAME});
+            const room2 = sfu2.getRoom({name: ROOM_NAME});
+            const messageHandler = (message) => {
+                expect(message).toBeTruthy();
+                expect(message.message).toEqual(msg);
+                room.off(sfu.constants.SFU_ROOM_EVENT.MESSAGE, messageHandler);
+                done();
+            }
+            room.on(sfu.constants.SFU_ROOM_EVENT.MESSAGE, messageHandler);
+            room2.sendMessage(msg);
+        });
+
+        it("should leave the room", async () => {
+            const room2 = sfu2.getRoom({name: ROOM_NAME});
+            await room2.leaveRoom();
+            await waitForPeerConnectionState(room2.pc(), "closed");
+        });
+
+        it("the owner should be able to move it to the waiting room", async (done) => {
+            const room = sfu.getRoom({name: ROOM_NAME});
+            room.on(sfu.constants.SFU_ROOM_EVENT.JOINED, async (participant) => {
+                await room.moveToWaitingRoom(participant.name);
+                done();
+            });
+            await room.configureWaitingRoom(false);
+            const room2 = sfu2.room({
+                name: ROOM_NAME,
+                pin: PIN,
+                pc: new wrtc.RTCPeerConnection()
+            });
+            await room2.join({});
+        });
+    });
+
+    it("should update room state", async () => {
+        const room = sfu.getRoom({name: ROOM_NAME});
+        // Audio track
+        const aSource = new RTCAudioSourceSineWave();
+        const aTrack = aSource.createTrack();
+        const aSender = room.pc().addTrack(aTrack);
+        // Video track
+        const vSource = new RTCVideoSourceWrapper();
+        const vTrack = vSource.createTrack();
+        const vSender = room.pc().addTrack(vTrack);
+
+        await room.updateState({});
+        await waitForPeerConnectionStableState(room.pc());
+        aTrack.stop();
+        aSource.close();
+        vTrack.stop();
+        room.pc().removeTrack(aSender);
+        room.pc().removeTrack(vSender);
+        await room.updateState();
+        await waitForPeerConnectionStableState(room.pc());
+    });
+
+    it("should leave room", async () => {
+        const room = sfu.getRoom({name: ROOM_NAME});
+        const ret = await room.leaveRoom();
+        expect(ret).toBeTruthy();
+    });
+
+    it("should destroy room", async (done) => {
+        const room = sfu.room({
+            name: ROOM_NAME,
+            pin: PIN,
+            pc: new wrtc.RTCPeerConnection()
+        });
+        room.on(constants.SFU_ROOM_EVENT.EVICTED, () => {
+            expect(sfu.getRoom({name: ROOM_NAME})).toBeFalsy();
+            done();
+        });
+        await room.createRoom();
+        await room.join();
+        await room.destroyRoom();
+    });
+});

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

@@ -1,3 +1,5 @@
+const fs = require("fs");
+const path = require("path");
 const sfu = require("../../sdk/sfu-extended");
 const constants = require("../../sdk/constants");
 
@@ -5,6 +7,8 @@ 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";
@@ -14,6 +18,11 @@ const MEMBERS = [
     "alice@flashphoner.com",
     "kiri@flashphoner.com"
 ];
+const FILE = "../assets/1.jpeg";
+
+jest.isolateModules(() => {
+    sfu2 = require("../../sdk/sfu-extended");
+});
 
 beforeAll( async () => {
     await sfu.connect({
@@ -27,10 +36,16 @@ beforeAll( async () => {
             await sfu.deleteChat({id: value.id});
         });
     }
+    await sfu2.connect({
+        url: SERVER,
+        username: USER2,
+        password: PASSWD
+    });
 });
 
-afterAll(() => {
-    return sfu.disconnect();
+afterAll(async () => {
+    await sfu.disconnect();
+    await sfu2.disconnect();
 });
 
 
@@ -61,6 +76,36 @@ describe("chat", () => {
             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();
@@ -76,7 +121,47 @@ describe("chat", () => {
         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({
@@ -101,6 +186,35 @@ describe("chat", () => {
             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();
@@ -110,14 +224,14 @@ describe("chat", () => {
             body: MESSAGE_BODY
         });
     });
-    test("should receive ACK message", (done) => {
-        sfu.on(constants.SFU_EVENT.MESSAGE_STATE, (state) => {
-            done();
-        })
-        sfu.sendMessage({
+    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({

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

@@ -0,0 +1,265 @@
+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();
+    });
+});