3way-calling-3-ConferenceCall module (#899)

* implement ConferenceCall module

* add ConferenceCall module integration tests

* use cached profileImageUrl

Author: ruleechen

packages/ringcentral-integration/integration-test/commons/Phone/index.js

@@ -50,6 +50,7 @@ import ActivityMatcher from '../../../modules/ActivityMatcher';
 // import CallLog from '../CallLog';
 // import AutoLogger from '../AutoLogger';
 // import DataMatcher from '../DataMatcher';
+import ConferenceCall from '../../../modules/ConferenceCall';
 
 
 export default class Phone extends RcModule {
@@ -375,7 +376,9 @@ export default class Phone extends RcModule {
     }));
     this.contactSearch.addSearchSource({
       sourceName: 'test',
-      searchFn: ({ searchString }) => [{
+      searchFn: ({
+        searchString
+      }) => [{
         entityType: 'account',
         name: searchString,
         phoneNumber: '+1234567890',
@@ -444,6 +447,20 @@ export default class Phone extends RcModule {
     //   getState: () => this.state.adapter,
     // }));
 
+    this.addModule('conferenceCall', new ConferenceCall({
+      ...options,
+      auth: this.auth,
+      storage: this.storage,
+      client: this.client,
+      tabManager: this.tabManager,
+      alert: this.alert,
+      call: this.call,
+      callingSettings: this.callingSettings,
+      rolesAndPermissions: this.rolesAndPermissions,
+      pulling: false,
+      getState: () => this.state.conferenceCall,
+    }));
+
     this._reducer = combineReducers({
       app: (state = {
         name: appName,
@@ -488,6 +505,7 @@ export default class Phone extends RcModule {
       messageStore: this.messageStore.reducer,
       conversations: this.conversations.reducer,
       // adapter: this.adapter.reducer,
+      conferenceCall: this.conferenceCall.reducer,
     });
   }
 

packages/ringcentral-integration/integration-test/commons/specs/commons.spec.js

@@ -25,6 +25,7 @@ import runDialingPlanTests from '../../spec-modules/dialingPlan';
 import runRolesAndPermissionsTests from '../../spec-modules/rolesAndPermissions';
 import runExtensionPhoneNumberTests from '../../spec-modules/extensionPhoneNumber';
 import runPresenceTests from '../../spec-modules/presence';
+import runConferenceCallTests from '../../spec-modules/conferenceCall';
 
 let phone = getTestPhone();
 runNumValidInCallTests(phone.auth, phone.alert, phone.client, phone.regionSettings, phone.call,
@@ -150,3 +151,12 @@ runPresenceTests(
   phone.presence,
   defaultAccount,
 );
+
+phone = getTestPhone();
+runConferenceCallTests(
+  phone.auth,
+  phone.client,
+  phone.conferenceCall,
+  phone.alert,
+  defaultAccount,
+);

packages/ringcentral-integration/integration-test/mock/data/conferenceCall.json

@@ -0,0 +1,11 @@
+{
+  "session": {
+    "creationTime": "2018-05-29T14:40:44Z",
+    "id": "Y3MxNzI2MjI1NTQzODI0MzUzM0AxMC43NC4yLjIxOA",
+    "origin": {
+      "type": "Conference"
+    },
+    "parties": [],
+    "voiceCallToken": "conf_59334d784e7a49324d6a49314e54517a4f4449304d7a557a4d3041784d4334334e4334794c6a49784f414031302e37342e322e3231383a35303730"
+  }
+}

packages/ringcentral-integration/integration-test/mock/data/numberParse.json

@@ -0,0 +1,29 @@
+{
+  "uri": "http://api-xmnup.lab.nordigy.ru/restapi/v1.0/number-parser/parse?nationalAsPriority=false&homeCountry=US",
+  "homeCountry": {
+    "uri": "http://api-xmnup.lab.nordigy.ru/restapi/v1.0/dictionary/country/1",
+    "id": "1",
+    "name": "United States",
+    "isoCode": "US",
+    "callingCode": "1"
+  },
+  "phoneNumbers": [{
+    "originalString": "+12092313293",
+    "country": {
+      "uri": "http://api-xmnup.lab.nordigy.ru/restapi/v1.0/dictionary/country/1",
+      "id": "1",
+      "name": "United States",
+      "isoCode": "US",
+      "callingCode": "1"
+    },
+    "areaCode": "209",
+    "subscriberNumber": "2313293",
+    "formattedNational": "(209) 231-3293",
+    "formattedInternational": "+1 (209) 2313293",
+    "dialable": "2092313293",
+    "e164": "+12092313293",
+    "special": false,
+    "normalized": "12092313293",
+    "tollFree": false
+  }]
+}

packages/ringcentral-integration/integration-test/mock/index.js

@@ -28,6 +28,8 @@ const conferencingBody = require('./data/conferencing.json');
 const activeCallsBody = require('./data/activeCalls.json');
 const meetingBody = require('./data/meeting');
 const serviceInfoBody = require('./data/serviceInfo');
+const conferenceCallBody = require('./data/conferenceCall');
+const numberParseBody = require('./data/numberParse');
 
 const mockServer = 'http://whatever';
 export function createSDK(options = {}) {
@@ -61,7 +63,9 @@ export function mockApi({
   let responseHeaders;
   const isJson = typeof body !== 'string';
   if (isJson && !headers) {
-    responseHeaders = { 'Content-Type': 'application/json' };
+    responseHeaders = {
+      'Content-Type': 'application/json'
+    };
   } else {
     responseHeaders = headers;
   }
@@ -412,6 +416,31 @@ export function conferencing(mockResponse = {}) {
   });
 }
 
+export function numberParse(mockResponse = {}, homeCountry) {
+  mockApi({
+    method: 'POST',
+    path: `/restapi/v1.0/number-parser/parse?homeCountry=${homeCountry}`,
+    body: {
+      ...numberParseBody,
+      ...mockResponse,
+    },
+    isOnce: false
+  });
+}
+
+export function conferenceCall(mockResponse = {}) {
+  conferenceCallBody.session.on = () => {};
+  mockApi({
+    method: 'POST',
+    path: '/restapi/v1.0/account/~/telephony/conference',
+    body: {
+      ...conferenceCallBody,
+      ...mockResponse,
+    },
+    isOnce: false
+  });
+}
+
 export function activeCalls(mockResponse = {}) {
   mockApi({
     method: 'GET',
@@ -539,5 +568,3 @@ export function mockForLogin({
   }
   numberParser();
 }
-
-

packages/ringcentral-integration/integration-test/spec-modules/conferenceCall.js

@@ -0,0 +1,125 @@
+import {
+  ensureLogin,
+  containsErrorMessage
+} from '../utils/HelpUtil';
+import {
+  waitInSeconds
+} from '../utils/WaitUtil';
+import * as mock from '../mock';
+import ClientHistoryRequest from '../utils/ClientHistoryRequest';
+import conferenceCallErrors from '../../modules/ConferenceCall/conferenceCallErrors';
+import conferenceCallStatus from '../../modules/ConferenceCall/conferenceCallStatus';
+import callingOptions from '../../modules/CallingSettings/callingOptions';
+import callDirection from '../../enums/callDirections';
+import sinon from 'sinon';
+
+export default (auth, client, conferenceCall, alert, account) => {
+  describe('ConferenceCall:', function () {
+    this.timeout(20000);
+    mock.mockClient(client);
+    const clientHistoryRequest = new ClientHistoryRequest(new Map(), client);
+    let isLoginSuccess;
+
+    describe('Should Init Successfully with Default Setting', () => {
+      it('Should Have Empty Records of Conferences By Default', () => {
+        expect(conferenceCall.state.conferences).to.be.an('object').that.is.empty;
+      });
+      it('Should Be Idle By Default', () => {
+        expect(conferenceCall.state.conferenceCallStatus).to.equal(conferenceCallStatus.idle);
+      });
+    });
+
+    describe('Should Update Conference Successfully', function () {
+      after(async function () {
+        await auth.logout();
+        await waitInSeconds(1);
+      });
+
+      before(async function () {
+        mock.restore();
+        mock.mockForLogin({
+          mockAuthzProfile: false
+        });
+        isLoginSuccess = await ensureLogin(auth, account);
+
+        if (!isLoginSuccess) {
+          console.error('Skip test case as failed to login with credential ', account);
+          this.skip();
+        }
+        mock.conferenceCall();
+        mock.numberParse({}, 'US');
+      });
+
+      it('Should Update Records of Conferences When Request One', async () => {
+        let sessionData;
+        sessionData = await conferenceCall._makeConference();
+        const rawRequest =
+          clientHistoryRequest.getRawResponse(ClientHistoryRequest.endPoints.conferenceCall);
+        expect(JSON.stringify(sessionData)).to.equal(JSON.stringify(rawRequest.session));
+        // FIXME: because we are unable to mock sip.js instance, so skip the session assertation below:        
+        // expect(conferenceCall.conferences).to.have.key(rawRequest.session.id);
+      });
+
+      it('Should Not Have Failure Alert', () => {
+        Object.values(conferenceCallErrors).forEach(err => {
+          expect(containsErrorMessage(
+            alert.state.messages,
+            err
+          )).to.equal(undefined);
+        });
+      });
+    });
+
+    describe('Should Failed to Update Conference', async () => {
+      after(async function () {
+        await auth.logout();
+        await waitInSeconds(1);
+      });
+
+      before(async function () {
+        conferenceCall._reset();
+        mock.restore();
+        mock.mockForLogin({
+          mockAuthzProfile: false
+        });
+        isLoginSuccess = await ensureLogin(auth, account);
+
+        if (!isLoginSuccess) {
+          console.error('Skip test case as failed to login with credential ', account);
+          this.skip();
+        }
+        mock.mockForbidden({
+          method: 'POST',
+          path: ClientHistoryRequest.endPoints.conferenceCall
+        });
+        mock.numberParse({}, 'US');
+      });
+
+      it('Should Have No Records of Conference', async () => {
+        await conferenceCall._makeConference(false);
+        expect(conferenceCall.conferences).to.be.an('object').that.is.empty;
+      });
+
+      it('Should Have A Failure Alert', () => {
+        expect(containsErrorMessage(
+          alert.state.messages,
+          conferenceCallErrors.makeConferenceFailed
+        )).to.not.equal(undefined);
+      });
+
+      it('Should Not Bring Session into Non-existent Conference', async () => {
+        try {
+          await conferenceCall.bringInToConference(Math.random(), {
+            direction: callDirection.outbound
+          });
+        } catch (e) {
+          // skip the error that were throwed intentinally
+        }
+        expect(containsErrorMessage(
+          alert.state.messages,
+          conferenceCallErrors.makeConferenceFailed
+        )).to.not.equal(undefined);
+      });
+    });
+  });
+};

packages/ringcentral-integration/integration-test/utils/ClientHistoryRequest.js

@@ -6,6 +6,7 @@ export default class ClientHistoryRequest {
     token: '/restapi/oauth/token',
     companyPager: '/restapi/v1.0/account/~/extension/~/company-pager',
     sms: '/restapi/v1.0/account/~/extension/~/sms',
+    conferenceCall: '/restapi/v1.0/account/~/telephony/conference',
   }
 
   constructor(requestContainer, client) {

packages/ringcentral-integration/modules/ConferenceCall/actionTypes.js

@@ -0,0 +1,36 @@
+import Enum from '../../lib/Enum';
+import moduleActionTypes from '../../enums/moduleActionTypes';
+
+export default new Enum([
+  ...Object.keys(moduleActionTypes),
+  'mergeStart',
+  'mergeSucceeded',
+  'mergeFailed',
+  // make conference call
+  'makeConference',
+  'makeConferenceSucceeded',
+  'makeConferenceFailed',
+  // terminate
+  'terminateConference',
+  'terminateConferenceSucceeded',
+  'terminateConferenceFailed',
+  // update
+  'updateConference',
+  'updateConferenceSucceeded',
+  'updateConferenceFailed',
+  // get party
+  'getParty',
+  'getPartySucceeded',
+  'getPartyFailed',
+  // bring-in
+  'bringInConference',
+  'bringInConferenceSucceeded',
+  'bringInConferenceFailed',
+  // remove
+  'removeFromConference',
+  'removeFromConferenceSucceeded',
+  'removeFromConferenceFailed',
+  // update merge pairs
+  'updateFromSession',
+  'updateToSession',
+], 'conferenceCall');

packages/ringcentral-integration/modules/ConferenceCall/conferenceCallErrors.js

@@ -0,0 +1,12 @@
+import Enum from '../../lib/Enum';
+
+export default new Enum([
+  'internalServerError',
+  'conferenceForbidden',
+  'conferenceBadRequest',
+  'conferenceNotFound',
+  'conferenceConflict',
+  'modeError',
+  'makeConferenceFailed',
+  'bringInFailed',
+], 'conferenceCall');

packages/ringcentral-integration/modules/ConferenceCall/conferenceCallStatus.js

@@ -0,0 +1,6 @@
+import Enum from '../../lib/Enum';
+
+export default new Enum([
+  'idle',
+  'requesting',
+], 'conferenceCall');