@wazo/sdk 0.43.5 → 1.0.0-alpha.0

package/esm/__tests__/__voice__/call.test.js

@@ -0,0 +1,72 @@
+/* eslint-disable no-underscore-dangle */
+import { Inviter, UserAgent } from 'sip.js';
+import softphone from '../../voice/softphone';
+import Call from '../../voice/call';
+import { Actions, States } from '../../state-machine/call-state-machine';
+import { Actions as SoftphoneActions } from '../../state-machine/softphone-state-machine';
+import InvalidStateTransition from '../../domain/InvalidStateTransition';
+const uaOptions = {
+    logBuiltinEnabled: false,
+    transportOptions: {
+        traceSip: false,
+        wsServers: 'ws://localhost',
+    },
+};
+jest.mock('../..', () => ({
+    __esModule: true,
+    default: {
+        Auth: {
+            getHost: jest.fn(() => 'my-stack.io'),
+            getSession: jest.fn(() => ({
+                displayName: () => 'John Doe',
+                primaryWebRtcLine: () => ({}),
+            })),
+        },
+    },
+}));
+jest.mock('../../web-rtc-client', () => jest.fn().mockImplementation(() => ({
+    answer: jest.fn(() => Promise.resolve()),
+    hangup: jest.fn(() => Promise.resolve()),
+    register: jest.fn(() => Promise.resolve()),
+    setOnHeartbeatTimeout: jest.fn(() => Promise.resolve()),
+    setOnHeartbeatCallback: jest.fn(() => Promise.resolve()),
+    on: jest.fn(),
+})));
+const ua = new UserAgent(uaOptions);
+const sipCall = new Inviter(ua, UserAgent.makeURI('sip:1234@my.stack.io'));
+softphone.connect();
+softphone._sendAction(SoftphoneActions.REGISTER_DONE);
+const invalidStateTransition = (state, action) => new InvalidStateTransition(`Invalid state transition from ${state} with action ${action}`, state, action);
+describe('Call', () => {
+    describe('accept', () => {
+        it('Should throw an error when accepting a not ringing call', async () => {
+            const call = new Call(sipCall, softphone);
+            await expect(call.accept()).rejects.toThrowError(invalidStateTransition(States.IDLE, Actions.ACCEPT));
+        });
+        it.only('Should throw an error when the softphone is not registered', async () => {
+            const call = new Call(sipCall, softphone);
+            call._sendAction(Actions.INCOMING_CALL);
+            softphone._sendAction(SoftphoneActions.TRANSPORT_CLOSED);
+            await expect(call.accept()).rejects.toThrowError(invalidStateTransition(States.RINGING, Actions.ACCEPT));
+        });
+        it('Should not throw an error when accepting a not ringing call', async () => {
+            const call = new Call(sipCall, softphone);
+            call._sendAction(Actions.INCOMING_CALL);
+            await call.accept();
+            expect(softphone.client.answer).toHaveBeenCalled();
+        });
+    });
+    describe('hangup', () => {
+        it('Should throw an error when terminating a non established call', async () => {
+            const call = new Call(sipCall, softphone);
+            await expect(call.hangup()).rejects.toThrowError(invalidStateTransition(States.IDLE, Actions.HANGUP));
+        });
+        it('Should not throw an error when terminating an established call', async () => {
+            const call = new Call(sipCall, softphone);
+            call._sendAction(Actions.MAKE_CALL);
+            call._sendAction(Actions.REMOTLY_ACCEPTED);
+            await call.hangup();
+            expect(softphone.client.hangup).toHaveBeenCalled();
+        });
+    });
+});

package/esm/__tests__/__voice__/softphone.test.js

@@ -0,0 +1,66 @@
+import { Softphone } from '../../voice/softphone';
+import { Actions, States } from '../../state-machine/softphone-state-machine';
+import Wazo from '../..';
+import InvalidStateTransition from '../../domain/InvalidStateTransition';
+const server = 'my.stack.io';
+const displayName = 'John Doe';
+const webRtcLine = {};
+const session = {
+    uuid: '1234',
+    displayName: jest.fn(() => displayName),
+    primaryWebRtcLine: jest.fn(() => webRtcLine),
+};
+jest.mock('../..', () => ({
+    __esModule: true,
+    default: {
+        Auth: {
+            getHost: jest.fn(() => server),
+            getSession: jest.fn(() => session),
+        },
+    },
+}));
+jest.mock('../../web-rtc-client', () => jest.fn().mockImplementation(() => ({
+    register: jest.fn(() => Promise.resolve()),
+    unregister: jest.fn(() => Promise.resolve()),
+    setOnHeartbeatTimeout: jest.fn(() => Promise.resolve()),
+    setOnHeartbeatCallback: jest.fn(() => Promise.resolve()),
+    on: jest.fn(),
+    INVITE: 'invite',
+})));
+const invalidStateTransition = (state, action) => new InvalidStateTransition(`Invalid state transition from ${state} with action ${action}`, state, action);
+describe('Softphone', () => {
+    describe('connect', () => {
+        it('Should retrieve information from Wazo.Auth', () => {
+            const instance = new Softphone();
+            jest.spyOn(instance, 'connectWithCredentials');
+            instance.connect({});
+            expect(Wazo.Auth.getHost).toHaveBeenCalled();
+            expect(Wazo.Auth.getSession).toHaveBeenCalled();
+            expect(instance.connectWithCredentials).toHaveBeenCalledWith(server, webRtcLine, displayName, { userUuid: session.uuid });
+            expect(instance.client.on).toHaveBeenCalledWith('invite', expect.anything());
+        });
+        it('Should throw an error when already connected', async () => {
+            const instance = new Softphone();
+            instance.softphoneActor.send({ type: Actions.REGISTER });
+            await expect(instance.connect({})).rejects.toThrowError(invalidStateTransition(States.REGISTERING, Actions.REGISTER));
+        });
+        it('Should not allow to register twice', async () => {
+            const instance = new Softphone();
+            instance.connect({});
+            await expect(instance.connect({})).rejects.toThrowError(invalidStateTransition(States.REGISTERING, Actions.REGISTER));
+        });
+    });
+    describe('disconnect', () => {
+        it('Should throw an error when not connected', async () => {
+            const instance = new Softphone();
+            await expect(instance.disconnect()).rejects.toThrowError(invalidStateTransition(States.UNREGISTERED, Actions.UNREGISTER));
+        });
+        it('Should unregister the client', async () => {
+            const instance = new Softphone();
+            instance.connect({});
+            instance.softphoneActor.send({ type: Actions.REGISTER_DONE });
+            await instance.disconnect();
+            expect(instance.client.unregister).toHaveBeenCalled();
+        });
+    });
+});

package/esm/api/auth.js

@@ -36,10 +36,6 @@ export default ((client, baseUrl) => ({
         const body = {
             saml_session_id: samlSessionId,
         };
-        if (client.clientId) {
-            body.access_type = 'offline';
-            body.client_id = client.clientId;
-        }
         return client.post(`${baseUrl}/token`, body).then(Session.parse);
     },
     initiateIdpAuthentication: async (domain, redirectUrl) => {
@@ -51,7 +47,7 @@ export default ((client, baseUrl) => ({
             Accept: 'application/json',
             'Content-Type': 'application/json',
         };
-        return client.post(`${baseUrl}/saml/sso`, body, headers);
+        return client.post(`${baseUrl}/saml/sso`, body, headers, (response) => response);
     },
     refreshToken: (refreshToken, backend, expiration, isMobile, tenantId, domainName) => {
         const body = {

package/esm/checker/checks/webrtc.js

@@ -1,4 +1,5 @@
 /* global MediaStream */
+import { getSipSessionId } from '../../utils/sdp';
 import WebRTCClient from '../../web-rtc-client';
 export default {
     name: 'WebRTC',
@@ -28,7 +29,7 @@ export default {
         });
         client.on(client.REGISTERED, () => {
             const sipSession = client.call('*10');
-            if (!sipSession || !client.getSipSessionId(sipSession)) {
+            if (!sipSession || !getSipSessionId(sipSession)) {
                 return handleError('Unable to make call through WebRTC');
             }
             setTimeout(() => {

package/esm/domain/InvalidState.js

@@ -0,0 +1,8 @@
+class InvalidState extends Error {
+    state;
+    constructor(message, state) {
+        super(message);
+        this.state = state;
+    }
+}
+export default InvalidState;

package/esm/domain/InvalidStateTransition.js

@@ -0,0 +1,10 @@
+class InvalidStateTransition extends Error {
+    state;
+    action;
+    constructor(message, action, state) {
+        super(message);
+        this.action = action;
+        this.state = state;
+    }
+}
+export default InvalidStateTransition;

package/esm/domain/Phone/WebRTCPhone.js

@@ -3,6 +3,8 @@ import { Invitation } from 'sip.js/lib/api';
 import CallSession from '../CallSession';
 import Emitter from '../../utils/Emitter';
 import IssueReporter from '../../service/IssueReporter';
+import { getSipSessionId } from '../../utils/sdp';
+import { downgradeToAudio, getStreamFromConstraints, getWebRtcStats, setLocalMediaStream, upgradeToVideo } from '../../utils/webrtc';
 export const ON_USER_AGENT = 'onUserAgent';
 export const ON_REGISTERED = 'onRegistered';
 export const ON_UNREGISTERED = 'onUnRegistered';
@@ -219,7 +221,7 @@ export default class WebRTCPhone extends Emitter {
             id: callSession ? callSession.getId() : null,
             withMessage,
         });
-        this.client.downgradeToAudio(sipSession);
+        downgradeToAudio(sipSession);
         if (callSession) {
             callSession.cameraEnabled = false;
             this._updateCallSession(callSession);
@@ -244,7 +246,7 @@ export default class WebRTCPhone extends Emitter {
         const desktop = constraints && constraints.desktop;
         const options = sipSession.sessionDescriptionHandlerOptionsReInvite;
         const wasAudioOnly = options?.audioOnly;
-        const newStream = await this.client.upgradeToVideo(sipSession, constraints, isConference);
+        const newStream = await upgradeToVideo(sipSession, constraints, isConference);
         if (callSession) {
             callSession.cameraEnabled = true;
             this._updateCallSession(callSession);
@@ -277,16 +279,15 @@ export default class WebRTCPhone extends Emitter {
                 content: {
                     type: ON_MESSAGE_TRACK_UPDATED,
                     update: isUpgrade ? 'upgrade' : 'downgrade',
-                    sipCallId: sipSession && this.getSipSessionId(sipSession),
+                    sipCallId: sipSession && getSipSessionId(sipSession),
                     callId: callSession ? callSession.callId : null,
                     number: callSession ? callSession.number : null,
-                    callerNumber: callSession ? callSession.callerNumber : null,
                 },
             }));
         }, 2500);
     }
     _bindEvents(sipSession) {
-        const sipSessionId = this.getSipSessionId(sipSession);
+        const sipSessionId = getSipSessionId(sipSession);
         if (sipSession instanceof Invitation) {
             // Monkey patch to know when canceled with the CANCEL message
             const onCancel = sipSession._onCancel.bind(sipSession);
@@ -340,7 +341,7 @@ export default class WebRTCPhone extends Emitter {
             const [stream] = event.streams;
             const kind = event && event.track && event.track.kind;
             logger.info('on track stream called on the peer connection', {
-                callId: this.getSipSessionId(sipSession),
+                callId: getSipSessionId(sipSession),
                 streamId: stream ? stream.id : null,
                 tracks: stream ? stream.getTracks() : null,
                 kind,
@@ -363,15 +364,15 @@ export default class WebRTCPhone extends Emitter {
             constraints,
             id: callSession ? callSession.getId() : null,
         });
-        const screenShareStream = await this.client.getStreamFromConstraints(constraints);
+        const screenShareStream = await getStreamFromConstraints(constraints);
         if (!screenShareStream) {
             throw new Error(`Can't create media stream for screensharing with: ${JSON.stringify(constraints)}`);
         }
         const screenTrack = screenShareStream.getVideoTracks()[0];
         const sipSession = this.currentSipSession;
-        const pc = sipSession && this.client.getPeerConnection(this.getSipSessionId(sipSession));
+        const pc = sipSession && this.client.getPeerConnection(getSipSessionId(sipSession));
         const sender = pc && pc.getSenders && pc.getSenders().find((s) => s && s.track && s.track.kind === 'video');
-        const localStream = sipSession && this.client.getLocalStream(this.getSipSessionId(sipSession));
+        const localStream = sipSession && this.client.getLocalStream(getSipSessionId(sipSession));
         const videoTrack = localStream ? localStream.getTracks().find(track => track.kind === 'video') : null;
         const hadVideo = !!videoTrack;
         // Stop local video tracks
@@ -433,19 +434,19 @@ export default class WebRTCPhone extends Emitter {
     }
     _onScreenSharing(screenStream, sipSession, callSession, hadVideo, desktop) {
         const screenTrack = screenStream.getVideoTracks()[0];
-        const sipSessionId = this.getSipSessionId(sipSession);
+        const sipSessionId = getSipSessionId(sipSession);
         const pc = this.client.getPeerConnection(sipSessionId);
         const sender = pc && pc.getSenders && pc.getSenders().find((s) => s && s.track && s.track.kind === 'video');
         logger.info('WebRTC phone - on screensharing', {
             hadVideo,
-            id: this.getSipSessionId(sipSession),
+            id: getSipSessionId(sipSession),
             screenTrack,
         });
         if (screenTrack) {
             screenTrack.onended = () => {
                 logger.info('WebRTC phone - on screenshare ended', {
                     hadVideo,
-                    id: this.getSipSessionId(sipSession),
+                    id: getSipSessionId(sipSession),
                     screenTrack,
                 });
                 this.eventEmitter.emit(ON_SHARE_SCREEN_ENDING, this._createCallSession(sipSession, callSession));
@@ -458,7 +459,7 @@ export default class WebRTCPhone extends Emitter {
             sipSessionId,
             desktop,
         };
-        this.client.setLocalMediaStream(this.getSipSessionId(sipSession), screenStream);
+        setLocalMediaStream(sipSession, screenStream);
         this.eventEmitter.emit(ON_SHARE_SCREEN_STARTED, this._createCallSession(sipSession, callSession, {
             screensharing: true,
         }), screenStream);
@@ -479,7 +480,7 @@ export default class WebRTCPhone extends Emitter {
         this.currentSipSession = sipSession;
         this.currentCallSession = callSession;
         this.eventEmitter.emit(ON_TERMINATE_SOUND, callSession, 'call accepted');
-        const sipSessionId = this.getSipSessionId(sipSession);
+        const sipSessionId = getSipSessionId(sipSession);
         if (sipSessionId) {
             this.removeIncomingSessions(sipSessionId);
         }
@@ -538,7 +539,7 @@ export default class WebRTCPhone extends Emitter {
         return this.currentSipSession && this.client.changeSessionVideoInputDevice(id, this.currentSipSession);
     }
     _onCallTerminated(sipSession) {
-        const sipSessionId = this.getSipSessionId(sipSession);
+        const sipSessionId = getSipSessionId(sipSession);
         logger.info('WebRTC phone - on call terminated', {
             sipId: sipSession.id,
             sipSessionId,
@@ -630,7 +631,7 @@ export default class WebRTCPhone extends Emitter {
         if (!this.currentSipSession) {
             return false;
         }
-        return this.currentSipSession && this.getSipSessionId(this.currentSipSession) === callSession.getId();
+        return this.currentSipSession && getSipSessionId(this.currentSipSession) === callSession.getId();
     }
     hasVideo(callSession) {
         return this.client.hasVideo(callSession.getId());
@@ -783,7 +784,7 @@ export default class WebRTCPhone extends Emitter {
         if (!sipSession) {
             return new Promise((resolve, reject) => reject(new Error('No session to hold')));
         }
-        const sessionId = this.getSipSessionId(sipSession);
+        const sessionId = getSipSessionId(sipSession);
         const hasVideo = this.client.hasLocalVideo(sessionId);
         logger.info('WebRTC hold sip session', {
             sipId: sipSession.id,
@@ -796,7 +797,7 @@ export default class WebRTCPhone extends Emitter {
         }
         // Downgrade to audio if needed
         if (hasVideo) {
-            await this.client.downgradeToAudio(sipSession);
+            await downgradeToAudio(sipSession);
         }
         const isConference = !!callSession && callSession.isConference();
         const promise = this.client.hold(sipSession, isConference, hasVideo);
@@ -810,7 +811,7 @@ export default class WebRTCPhone extends Emitter {
             return new Promise((resolve, reject) => reject(new Error('No session to unhold')));
         }
         const isConference = !!callSession && callSession.isConference();
-        const sessionId = this.getSipSessionId(sipSession);
+        const sessionId = getSipSessionId(sipSession);
         logger.info('WebRTC unhold sip session', {
             sessionId,
             isConference,
@@ -826,7 +827,7 @@ export default class WebRTCPhone extends Emitter {
                 screen: wasScreensharing,
                 desktop: wasDesktop,
             };
-            await this.client.upgradeToVideo(sipSession, constraints, isConference);
+            await upgradeToVideo(sipSession, constraints, isConference);
         }
         const onScreenSharing = (stream) => {
             const hadVideo = this.lastScreenShare && this.lastScreenShare.hadVideo;
@@ -1033,7 +1034,7 @@ export default class WebRTCPhone extends Emitter {
             console.error('Call is unknown to the WebRTC phone', callSession ? callSession.sipCallId : null, callSession ? callSession.callId : null);
             return false;
         }
-        const sipSessionId = this.getSipSessionId(sipSession);
+        const sipSessionId = getSipSessionId(sipSession);
         logger.info('WebRTC hangup', {
             sipId: sipSession.id,
             sipSessionId,
@@ -1051,7 +1052,7 @@ export default class WebRTCPhone extends Emitter {
     }
     async getStats(callSession) {
         const sipSession = this.findSipSession(callSession);
-        return sipSession ? this.client.getStats(sipSession) : null;
+        return sipSession ? getWebRtcStats(sipSession) : null;
     }
     startNetworkMonitoring(callSession, interval = 1000) {
         const sipSession = this.findSipSession(callSession);
@@ -1220,12 +1221,12 @@ export default class WebRTCPhone extends Emitter {
             // if `_createCallSession` is called too soon `hasVideo` will return false because the stream doesn't exists yet
             setTimeout(() => {
                 // Update callSession
-                this._createCallSession(sipSession, this.callSessions[this.getSipSessionId(sipSession)]);
+                this._createCallSession(sipSession, this.callSessions[getSipSessionId(sipSession)]);
                 this.eventEmitter.emit.apply(this.eventEmitter, [this.client.ON_REINVITE, ...args]);
             }, 2000);
         });
         this.client.on(this.client.ACCEPTED, async (sipSession) => {
-            const sessionId = this.getSipSessionId(sipSession);
+            const sessionId = getSipSessionId(sipSession);
             const hasSession = (sessionId in this.callSessions);
             logger.info('WebRTC call accepted', {
                 sipId: sessionId,
@@ -1252,7 +1253,7 @@ export default class WebRTCPhone extends Emitter {
             const callSession = this._createCallSession(session);
             // `_createCallSession` add the CallSession in `this.callSessions`.
             // so we have to remove it or `callCount` will always return 1 even if the call was rejected
-            delete this.callSessions[this.getSipSessionId(session)];
+            delete this.callSessions[getSipSessionId(session)];
             callSession.endTime = new Date();
             this.eventEmitter.emit(ON_CALL_REJECTED, callSession);
         });
@@ -1269,7 +1270,7 @@ export default class WebRTCPhone extends Emitter {
             const callSession = this._createCallSession(session, null, {
                 incoming: false,
                 ringing: true,
-                callId: this.getSipSessionId(session),
+                callId: getSipSessionId(session),
             });
             this.eventEmitter.emit(ON_PROGRESS, callSession, this.audioOutputDeviceId, this.audioOutputVolume);
         });
@@ -1278,7 +1279,7 @@ export default class WebRTCPhone extends Emitter {
             const callSession = this._createCallSession(session, null, {
                 incoming: false,
                 ringing: true,
-                callId: this.getSipSessionId(session),
+                callId: getSipSessionId(session),
             });
             this.eventEmitter.emit(ON_EARLY_MEDIA, callSession, this.audioOutputDeviceId, this.audioOutputVolume);
         });
@@ -1334,12 +1335,12 @@ export default class WebRTCPhone extends Emitter {
             this.eventEmitter.emit(ON_MESSAGE, message);
         });
         this.client.on(this.client.ON_NETWORK_STATS, (session, stats, previousStats) => {
-            const callSession = this.getCallSession(this.getSipSessionId(session));
+            const callSession = this.getCallSession(getSipSessionId(session));
             this.eventEmitter.emit(ON_NETWORK_STATS, callSession, stats, previousStats);
         });
         // Used when upgrading directly in screenshare mode
         this.client.on(this.client.ON_SCREEN_SHARING_REINVITE, (sipSession, response, desktop) => {
-            const sipSessionId = this.getSipSessionId(sipSession);
+            const sipSessionId = getSipSessionId(sipSession);
             const localStream = this.client.getLocalStream(sipSessionId);
             const callSession = this.callSessions[sipSessionId];
             logger.info('Updrading directly in screensharing mode', {
@@ -1354,7 +1355,7 @@ export default class WebRTCPhone extends Emitter {
         const keys = this.client.getSipSessionIds();
         const keyIndex = keys.findIndex(sessionId => callSession && callSession.isId(sessionId));
         if (keyIndex === -1) {
-            const currentSipSessionId = this.currentSipSession ? this.getSipSessionId(this.currentSipSession) : this.client.getSipSessionIds()[0];
+            const currentSipSessionId = this.currentSipSession ? getSipSessionId(this.currentSipSession) : this.client.getSipSessionIds()[0];
             return currentSipSessionId ? this.client.getSipSession(currentSipSessionId) : null;
         }
         return this.client.getSipSession(keys[keyIndex]);
@@ -1362,12 +1363,9 @@ export default class WebRTCPhone extends Emitter {
     getCallSession(sipSessionId) {
         return this.callSessions[sipSessionId];
     }
-    getSipSessionId(sipSession) {
-        return this.client.getSipSessionId(sipSession);
-    }
     getSipSessionIdFromCallSession(callSession) {
         const sipSession = this.findSipSession(callSession);
-        return sipSession ? this.getSipSessionId(sipSession) : null;
+        return sipSession ? getSipSessionId(sipSession) : null;
     }
     _updateCallSession(callSession) {
         const sipSessionId = this.getSipSessionIdFromCallSession(callSession);
@@ -1445,7 +1443,7 @@ export default class WebRTCPhone extends Emitter {
         // @ts-ignore: private
         const number = identity ? identity.uri._normal.user : null;
         const { state, } = sipSession || {};
-        const sessionId = this.getSipSessionId(sipSession);
+        const sessionId = getSipSessionId(sipSession);
         fromSession = fromSession || this.callSessions[sessionId];
         const callSession = new CallSession({
             callId: fromSession && fromSession.callId,

package/esm/simple/Auth.js

@@ -122,19 +122,25 @@ export class Auth {
         return this._onAuthenticated(rawSession);
     }
     async initiateIdpAuthentication(domain, redirectUrl) {
+        let response;
         try {
-            return await getApiClient().auth.initiateIdpAuthentication(domain, redirectUrl);
+            response = await getApiClient().auth.initiateIdpAuthentication(domain, redirectUrl);
         }
         catch (e) {
-            logger.error('Error during IdP authentication initialization:', e.message);
-            if (e.status === 404) {
-                throw new NoSamlRouteError('No route found for SAML SSO');
+            logger.error('Error during IdP authentication initiation:', e.message);
+            return;
+        }
+        if (!response.ok) {
+            if (response.status === 404) {
+                throw new NoSamlRouteError('No route found for saml sso');
             }
-            if (e.status === 500) {
+            if (response.status === 500) {
                 throw new SamlConfigError('SAML/server configuration error');
             }
-            throw e;
+            const error = await response.json();
+            throw new Error(error.message || error.reason);
         }
+        return response.json();
     }
     async logInViaRefreshToken(refreshToken) {
         const rawSession = await getApiClient().auth.refreshToken(refreshToken, '', this.expiration, this.mobile);

package/esm/simple/Phone.js

@@ -7,6 +7,7 @@ import IssueReporter from '../service/IssueReporter';
 import Emitter from '../utils/Emitter';
 import Wazo from './index';
 import SFUNotAvailableError from '../domain/SFUNotAvailableError';
+import { getSipSessionId } from '../utils/sdp';
 const logger = IssueReporter.loggerFor('simple-phone');
 const sipLogger = IssueReporter.loggerFor('sip.js');
 const protocolLogger = IssueReporter.loggerFor('sip');
@@ -230,7 +231,7 @@ export class Phone extends Emitter {
         if (!sipSession || !this.phone) {
             return null;
         }
-        return this.phone.getSipSessionId(sipSession);
+        return getSipSessionId(sipSession);
     }
     sendMessage(body, sipSession, contentType = 'text/plain') {
         const toSipSession = sipSession || this.getCurrentSipSession();

package/esm/simple/__tests__/Auth.test.js

@@ -1,5 +1,3 @@
-import BadResponse from '../../domain/BadResponse';
-import ServerError from '../../domain/ServerError';
 import getApiClient, { setRefreshToken } from '../../service/getApiClient';
 import { Auth as AuthClass } from '../Auth';
 const Auth = new AuthClass();
@@ -112,8 +110,12 @@ describe('simple/Auth', () => {
     });
     describe('initiateIdpAuthentication', () => {
         const validResponse = { location: 'idp.com/auth', saml_session_id: 'a1b2C3d4' };
-        it('should return a `location` and `saml_session_id` if the response is valid', async () => {
-            const initiateIdpAuthentication = jest.fn(() => validResponse);
+        it('should return a `location` and `saml_session_id` if the response is ok', async () => {
+            const initiateIdpAuthentication = jest.fn(() => Promise.resolve({
+                ok: true,
+                status: 303,
+                json: () => Promise.resolve(validResponse),
+            }));
             getApiClient.mockImplementation(() => ({
                 auth: {
                     initiateIdpAuthentication,
@@ -123,16 +125,70 @@ describe('simple/Auth', () => {
             expect(response).toBe(validResponse);
         });
         it('should return a `NoSamlRouteError` if the response is a 404', async () => {
-            const initiateIdpAuthentication = jest.fn(() => { throw BadResponse.fromText('an error message', 404); });
+            const initiateIdpAuthentication = jest.fn(() => Promise.resolve({
+                ok: false,
+                status: 404,
+            }));
+            getApiClient.mockImplementation(() => ({
+                auth: {
+                    initiateIdpAuthentication,
+                },
+            }));
+            await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow('No route found for saml sso');
+        });
+        it('should return an error `message` if the response is NOT ok', async () => {
+            const initiateIdpAuthentication = jest.fn(() => Promise.resolve({
+                ok: false,
+                json: () => Promise.resolve({ message: 'an error message', reason: 'an error reason' }),
+            }));
+            getApiClient.mockImplementation(() => ({
+                auth: {
+                    initiateIdpAuthentication,
+                },
+            }));
+            await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow('an error message');
+        });
+        it('should return an error `reason` if there is no `message` and the response is NOT ok', async () => {
+            const initiateIdpAuthentication = jest.fn(() => Promise.resolve({
+                ok: false,
+                json: () => Promise.resolve({ reason: 'an error reason' }),
+            }));
             getApiClient.mockImplementation(() => ({
                 auth: {
                     initiateIdpAuthentication,
                 },
             }));
-            await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow('No route found for SAML SSO');
+            await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow('an error reason');
         });
-        it('should return a `SamlConfigError` if the response is a 500', async () => {
-            const initiateIdpAuthentication = jest.fn(() => { throw ServerError.fromText('an error message', 500); });
+        it('should return an error with a null message if there is no `message` and `reason`', async () => {
+            const initiateIdpAuthentication = jest.fn(() => Promise.resolve({
+                ok: false,
+                json: () => Promise.resolve({}),
+            }));
+            getApiClient.mockImplementation(() => ({
+                auth: {
+                    initiateIdpAuthentication,
+                },
+            }));
+            await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow('');
+        });
+        it('should return a NoSAMLRouteError if the response is a 404', async () => {
+            const initiateIdpAuthentication = jest.fn(() => Promise.resolve({
+                ok: false,
+                status: 404,
+            }));
+            getApiClient.mockImplementation(() => ({
+                auth: {
+                    initiateIdpAuthentication,
+                },
+            }));
+            await expect(Auth.initiateIdpAuthentication('example.com', 'https://myapp.xyz')).rejects.toThrow('No route found for saml sso');
+        });
+        it('should return a SamlConfigError if the response is a 500', async () => {
+            const initiateIdpAuthentication = jest.fn(() => Promise.resolve({
+                ok: false,
+                status: 500,
+            }));
             getApiClient.mockImplementation(() => ({
                 auth: {
                     initiateIdpAuthentication,

package/esm/simple/index.js

@@ -17,7 +17,7 @@ import { CanceledCallError } from '../web-rtc-client';
 import BadResponse from '../domain/BadResponse';
 import ServerError from '../domain/ServerError';
 import SFUNotAvailableError from '../domain/SFUNotAvailableError';
-import Call from '../domain/Call';
+import ApiCall from '../domain/Call';
 import CallLog from '../domain/CallLog';
 import Recording from '../domain/Recording';
 import ChatMessage from '../domain/ChatMessage';
@@ -40,6 +40,8 @@ import IssueReporter from '../service/IssueReporter';
 import Features from '../domain/Features';
 import Meeting from '../domain/Meeting';
 import Checker from '../checker/Checker';
+import Softphone from '../voice/softphone';
+import Call from '../voice/call';
 const Wazo = {
     Auth,
     Phone,
@@ -59,11 +61,15 @@ const Wazo = {
     loggerFor: IssueReporter.loggerFor.bind(IssueReporter),
     Features,
     Checker,
+    Voice: {
+        Softphone,
+        Call,
+    },
     // Domain
     domain: {
         BadResponse,
         ServerError,
-        Call,
+        Call: ApiCall,
         CallLog,
         CTIPhone,
         Recording,