@flashphoner/sfusdk 1.0.43 → 1.0.47

package/docTemplate/README.md

@@ -1,4 +1,4 @@
-SFU SDK - 1.0.43
+SFU SDK - 1.0.47
 
 [Download builds](https://docs.flashphoner.com/display/SS1E/Release+notes)
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@flashphoner/sfusdk",
   "description": "Official Flashphoner WebCallServer SFU SDK package",
-  "version": "1.0.43",
+  "version": "1.0.47",
   "scripts": {
     "test": "jest --runInBand"
   },

package/src/sdk/constants.js

@@ -295,6 +295,7 @@ const constants = Object.freeze({
          * @memberof FlashphonerSFU.SFU_ROOM_EVENT
          */
         WAITING_LIST: "SFU_WAITING_LIST",
+        WAITING_ROOM_UPDATE: "SFU_WAITING_ROOM_UPDATE",
         /**
          * Fires when mute/unmute state of one of the Room's participating tracks changes
          * Event object {@link FlashphonerSFU.Room.TracksInfo}

package/src/sdk/room.js

@@ -59,7 +59,7 @@ const room = function(options) {
                 notify(message.type, message.message);
             }
         } else if (message.type === constants.SFU_EVENT.ACK && promises.promised(message.internalMessageId)) {
-                promises.resolve(message.internalMessageId);
+            promises.resolve(message.internalMessageId);
         } else {
             notify(message.type, message.message);
         }
@@ -117,6 +117,8 @@ const room = function(options) {
             if (!promises.resolve(e.internalMessageId, e)) {
                 notify(e.type, e);
             }
+        } else if (e.type === constants.SFU_ROOM_EVENT.WAITING_ROOM_UPDATE && promises.promised(e.internalMessageId)) {
+            promises.resolve(e.internalMessageId, e.enabled);
         } else if (e.type === constants.SFU_EVENT.ACK && promises.promised(e.internalMessageId)) {
             promises.resolve(e.internalMessageId);
         } else {

package/src/sdk/sfu-extended.js

@@ -71,7 +71,7 @@ function setupConnection(connection) {
                     notify(SFU_EVENT.CHAT_LOADED, msg[0].chat);
                 } else if (msg[0].type === constants.SFU_ROOM_EVENT.OPERATION_FAILED && promises.promised(msg[0].internalMessageId)) {
                     promises.reject(msg[0].internalMessageId, msg[0]);
-                } else if (msg[0].type === constants.SFU_EVENT.ACK && promises.promised(msg[0].internalMessageId && !msg[0].roomName)) {
+                } else if (msg[0].type === constants.SFU_EVENT.ACK && promises.promised(msg[0].internalMessageId)) {
                     promises.resolve(msg[0].internalMessageId);
                 } else if (msg[0].roomName && msg[0].roomName.length > 0) {
                     //room event
@@ -138,7 +138,8 @@ const connect = function(options) {
         connection.connect(connectionConfig).then(function (connectionConfig) {
             user = Object.freeze({
                 username: connectionConfig[0].sipLogin,
-                nickname: connectionConfig[0].sipVisibleName
+                nickname: connectionConfig[0].sipVisibleName,
+                pmi: connectionConfig[0].pmi
             });
             state = SFU_STATE.AUTHENTICATED;
             notify(SFU_EVENT.CONNECTED);

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

@@ -224,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();
+    });
+});