@webex/plugin-meetings 2.2.2 → 2.3.0

package/src/locus-info/infoUtils.js

@@ -1,12 +1,27 @@
 
+import {SELF_ROLES} from '../constants';
+
 const InfoUtils = {};
 
-InfoUtils.parse = (info) => {
+InfoUtils.parse = (info, roles) => {
   const parsed = {
     policy: InfoUtils.parsePolicy(info),
-    moderator: InfoUtils.parseModerator(info)
+    moderator: InfoUtils.parseModerator(info),
+    coHost: InfoUtils.parseCoHost(info),
   };
 
+  let userDisplayHints = {...parsed.policy};
+
+  if (roles.includes(SELF_ROLES.COHOST)) {
+    userDisplayHints = {...userDisplayHints, ...parsed.coHost};
+  }
+
+  if (roles.includes(SELF_ROLES.MODERATOR)) {
+    userDisplayHints = {...userDisplayHints, ...parsed.moderator};
+  }
+
+  parsed.userDisplayHints = Object.keys(userDisplayHints);
+
   if (info.sipUri) {
     parsed.sipUri = info.sipUri;
   }
@@ -17,43 +32,36 @@ InfoUtils.parse = (info) => {
 
   return parsed;
 };
-InfoUtils.parsePolicy = (info) => {
-  const policy = {};
-
-  // Parses the policy to show valid uses
-  if (info && info.displayHints && info.displayHints.joined && info.displayHints.joined.length > 0) {
-    // TODO: find a better way
-    info.displayHints.joined.forEach((key) => {
-      policy[key] = true;
+
+InfoUtils.parseDisplayHintSection = (info, displayHintKey) => {
+  const displayHints = {};
+
+  if (info && info.displayHints && info.displayHints[displayHintKey] && info.displayHints[displayHintKey].length > 0) {
+    info.displayHints[displayHintKey].forEach((key) => {
+      displayHints[key] = true;
     });
   }
 
-  return policy;
+  return displayHints;
 };
 
-InfoUtils.parseModerator = (info) => {
-  const moderator = {};
+InfoUtils.parsePolicy = (info) => InfoUtils.parseDisplayHintSection(info, 'joined');
 
-  if (info && info.displayHints && info.displayHints.moderator && info.displayHints.moderator.length > 0) {
-    info.displayHints.moderator.forEach((key) => {
-      moderator[key] = true;
-    });
-  }
+InfoUtils.parseModerator = (info) => InfoUtils.parseDisplayHintSection(info, 'moderator');
 
-  return moderator;
-};
+InfoUtils.parseCoHost = (info) => InfoUtils.parseDisplayHintSection(info, 'coHost');
 
 InfoUtils.isLocked = (policy) => policy.LOCK_STATUS_LOCKED || false;
 
 InfoUtils.isUnlocked = (policy) => policy.LOCK_STATUS_UNLOCKED || false;
 
-InfoUtils.getInfos = (oldInfo, newInfo) => {
+InfoUtils.getInfos = (oldInfo, newInfo, roles) => {
   let previous = null;
 
   if (oldInfo) {
     previous = oldInfo;
   }
-  const current = newInfo && InfoUtils.parse(newInfo);
+  const current = newInfo && InfoUtils.parse(newInfo, roles);
   const updates = {};
 
   if (current) {

package/src/locus-info/selfUtils.js

@@ -53,13 +53,22 @@ SelfUtils.parse = (self, deviceId) => {
       selfId: self.id,
       selfIdentity: SelfUtils.getSelfIdentity(self),
       selfUrl: self.url,
-      removed: self.removed
+      removed: self.removed,
+      roles: SelfUtils.getRoles(self)
     };
   }
 
   return null;
 };
 
+SelfUtils.getRoles = (self) => (self?.controls?.role?.roles || []).reduce((roles, role) => {
+  if (role.hasRole) {
+    roles.push(role.type);
+  }
+
+  return roles;
+}, []);
+
 SelfUtils.getSelves = (oldSelf, newSelf, deviceId) => {
   const previous = oldSelf && SelfUtils.parse(oldSelf, deviceId);
   const current = newSelf && SelfUtils.parse(newSelf, deviceId);

package/src/meeting/in-meeting-actions.js

@@ -16,30 +16,39 @@ export default class InMeetingActions {
     this.canLock = null;
     this.canUnlock = null;
     this.canAssignHost = null;
+    this.canStartRecording = null;
+    this.canPauseRecording = null;
+    this.canResumeRecording = null;
+    this.canStopRecording = null;
   }
 
-  setCanLock(lock) {
-    this.canLock = lock;
+  get() {
+    return {
+      canLock: this.canLock,
+      canUnlock: this.canUnlock,
+      canAssignHost: this.canAssignHost,
+      canStartRecording: this.canStartRecording,
+      canPauseRecording: this.canPauseRecording,
+      canResumeRecording: this.canResumeRecording,
+      canStopRecording: this.canStopRecording
+    };
   }
 
-  setCanUnlock(unlock) {
-    this.canUnlock = unlock;
-  }
+  set(actions) {
+    const old = this.get();
 
-  setCanAssignHost(host) {
-    this.canAssignHost = host;
-  }
+    let changed = false;
 
-  getCanLock() {
-    return this.canLock;
-  }
+    Object.keys(old).forEach((actionKey) => {
+      const actionValue = actions[actionKey];
 
-  getCanUnlock() {
-    return this.canUnlock;
-  }
+      if (actionValue !== undefined && actionValue !== old[actionKey]) {
+        changed = true;
+        this[actionKey] = actionValue;
+      }
+    });
 
-  getCanAssignHost() {
-    return this.canAssignHost;
+    return changed;
   }
 }
 

package/src/meeting/index.js

@@ -1144,20 +1144,21 @@ export default class Meeting extends StatelessWebexPlugin {
    */
   setUpLocusInfoAssignHostListener() {
     this.locusInfo.on(EVENTS.LOCUS_INFO_CAN_ASSIGN_HOST, (payload) => {
-      Trigger.trigger(
-        this,
-        {
-          file: 'meeting/index',
-          function: 'setUpLocusInfoAssignHostListener'
-        },
-        EVENT_TRIGGERS.MEETING_ACTIONS_UPDATE,
-        {
-          canAssignHost: payload.canAssignHost,
-          canLock: this.inMeetingActions.getCanLock(),
-          canUnlock: this.inMeetingActions.getCanUnlock()
-        }
-      );
-      this.inMeetingActions.setCanAssignHost(payload.canAssignHost);
+      const changed = this.inMeetingActions.set({
+        canAssignHost: payload.canAssignHost,
+      });
+
+      if (changed) {
+        Trigger.trigger(
+          this,
+          {
+            file: 'meeting/index',
+            function: 'setUpLocusInfoAssignHostListener'
+          },
+          EVENT_TRIGGERS.MEETING_ACTIONS_UPDATE,
+          this.inMeetingActions.get()
+        );
+      }
     });
   }
 
@@ -1862,34 +1863,16 @@ export default class Meeting extends StatelessWebexPlugin {
     });
     this.locusInfo.on(LOCUSINFO.EVENTS.MEETING_INFO_UPDATED, (payload) => {
       if (payload && payload.info) {
-        let newCanLock;
-        let newCanUnlock;
-
-        if (payload.self && !payload.self.moderator) {
-          newCanLock = false;
-          newCanUnlock = false;
-        }
-        else {
-          newCanLock = MeetingUtil.canUserLock(payload.info.moderator, payload.info.policy);
-          newCanUnlock = MeetingUtil.canUserUnlock(payload.info.moderator, payload.info.policy);
-        }
+        const changed = this.inMeetingActions.set({
+          canLock: MeetingUtil.canUserLock(payload.info.userDisplayHints),
+          canUnlock: MeetingUtil.canUserUnlock(payload.info.userDisplayHints),
+          canStartRecording: MeetingUtil.canUserRecord(payload.info.userDisplayHints),
+          canStopRecording: MeetingUtil.canUserStop(payload.info.userDisplayHints),
+          canPauseRecording: MeetingUtil.canUserPause(payload.info.userDisplayHints),
+          canResumeRecording: MeetingUtil.canUserResume(payload.info.userDisplayHints)
+        });
 
-        if (newCanLock && !this.inMeetingActions.canLock) {
-          Trigger.trigger(
-            this,
-            {
-              file: 'meeting/index',
-              function: 'setUpLocusInfoMeetingInfoListener'
-            },
-            EVENT_TRIGGERS.MEETING_ACTIONS_UPDATE,
-            {
-              canLock: true,
-              canUnlock: false,
-              canAssignHost: this.inMeetingActions.getCanAssignHost()
-            }
-          );
-        }
-        if (newCanUnlock && !this.inMeetingActions.canUnlock || !newCanLock) {
+        if (changed) {
           Trigger.trigger(
             this,
             {
@@ -1897,15 +1880,9 @@ export default class Meeting extends StatelessWebexPlugin {
               function: 'setUpLocusInfoMeetingInfoListener'
             },
             EVENT_TRIGGERS.MEETING_ACTIONS_UPDATE,
-            {
-              canLock: false,
-              canUnlock: true,
-              canAssignHost: this.inMeetingActions.getCanAssignHost()
-            }
+            this.inMeetingActions.get()
           );
         }
-        this.inMeetingActions.setCanLock(newCanLock || false);
-        this.inMeetingActions.setCanUnlock(newCanUnlock || false);
       }
     });
   }

package/src/meeting/util.js

@@ -7,16 +7,15 @@ import {eventType, trigger, mediaType} from '../metrics/config';
 import Media from '../media';
 import LoggerProxy from '../common/logs/logger-proxy';
 import WebRTCStats from '../stats/index';
-import {
-  INTENT_TO_JOIN,
+import {INTENT_TO_JOIN,
   _LEFT_,
   _IDLE_,
   _JOINED_,
   STATS,
   EVENT_TRIGGERS,
-  FULL_STATE,
   PASSWORD_STATUS,
-} from '../constants';
+  DISPLAY_HINTS,
+  FULL_STATE} from '../constants';
 import Trigger from '../common/events/trigger-proxy';
 import IntentToJoinError from '../common/errors/intent-to-join';
 import JoinMeetingError from '../common/errors/join-meeting';
@@ -388,34 +387,24 @@ MeetingUtil.getPolicyFromLocusInfo = (locusInfo) =>
   locusInfo.parsedLocus.info &&
   locusInfo.parsedLocus.info.policy;
 
-MeetingUtil.canUserLock = (moderator, joined) => {
-  if (moderator.LOCK_CONTROL_LOCK && joined.LOCK_STATUS_UNLOCKED) {
-    return true;
-  }
+MeetingUtil.getUserDisplayHintsFromLocusInfo = (locusInfo) => locusInfo?.parsedLocus?.info?.userDisplayHints || [];
 
-  return false;
-};
+MeetingUtil.canUserLock = (displayHints) => displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_LOCK) && displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_UNLOCKED);
 
-MeetingUtil.canUserUnlock = (moderator, joined) => {
-  if (moderator.LOCK_CONTROL_UNLOCK && joined.LOCK_STATUS_LOCKED) {
-    return true;
-  }
-
-  return false;
-};
+MeetingUtil.canUserUnlock = (displayHints) => displayHints.includes(DISPLAY_HINTS.LOCK_CONTROL_UNLOCK) && displayHints.includes(DISPLAY_HINTS.LOCK_STATUS_LOCKED);
 
-MeetingUtil.canUserRecord = (moderator) => moderator.RECORDING_CONTROL_START;
+MeetingUtil.canUserRecord = (displayHints) => displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_START);
 
-MeetingUtil.canUserPause = (moderator) => moderator.RECORDING_CONTROL_PAUSE;
+MeetingUtil.canUserPause = (displayHints) => displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_PAUSE);
 
-MeetingUtil.canUserResume = (moderator) => moderator.RECORDING_CONTROL_RESUME;
+MeetingUtil.canUserResume = (displayHints) => displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_RESUME);
 
-MeetingUtil.canUserStop = (moderator) => moderator.RECORDING_CONTROL_STOP;
+MeetingUtil.canUserStop = (displayHints) => displayHints.includes(DISPLAY_HINTS.RECORDING_CONTROL_STOP);
 
 MeetingUtil.startRecording = (request, locusUrl, locusInfo) => {
-  const moderator = MeetingUtil.getModeratorFromLocusInfo(locusInfo);
+  const displayHints = MeetingUtil.getUserDisplayHintsFromLocusInfo(locusInfo);
 
-  if (moderator && MeetingUtil.canUserRecord(moderator)) {
+  if (MeetingUtil.canUserRecord(displayHints)) {
     return request.recordMeeting({locusUrl, recording: true, paused: false});
   }
 
@@ -423,9 +412,9 @@ MeetingUtil.startRecording = (request, locusUrl, locusInfo) => {
 };
 
 MeetingUtil.pauseRecording = (request, locusUrl, locusInfo) => {
-  const moderator = MeetingUtil.getModeratorFromLocusInfo(locusInfo);
+  const displayHints = MeetingUtil.getUserDisplayHintsFromLocusInfo(locusInfo);
 
-  if (moderator && MeetingUtil.canUserPause(moderator)) {
+  if (MeetingUtil.canUserPause(displayHints)) {
     return request.recordMeeting({locusUrl, recording: true, paused: true});
   }
 
@@ -433,9 +422,9 @@ MeetingUtil.pauseRecording = (request, locusUrl, locusInfo) => {
 };
 
 MeetingUtil.resumeRecording = (request, locusUrl, locusInfo) => {
-  const moderator = MeetingUtil.getModeratorFromLocusInfo(locusInfo);
+  const displayHints = MeetingUtil.getUserDisplayHintsFromLocusInfo(locusInfo);
 
-  if (moderator && MeetingUtil.canUserResume(moderator)) {
+  if (MeetingUtil.canUserResume(displayHints)) {
     return request.recordMeeting({locusUrl, recording: true, paused: false});
   }
 
@@ -443,9 +432,9 @@ MeetingUtil.resumeRecording = (request, locusUrl, locusInfo) => {
 };
 
 MeetingUtil.stopRecording = (request, locusUrl, locusInfo) => {
-  const moderator = MeetingUtil.getModeratorFromLocusInfo(locusInfo);
+  const displayHints = MeetingUtil.getUserDisplayHintsFromLocusInfo(locusInfo);
 
-  if (moderator && MeetingUtil.canUserStop(moderator)) {
+  if (MeetingUtil.canUserStop(displayHints)) {
     return request.recordMeeting({locusUrl, recording: false, paused: false});
   }
 

package/src/metrics/index.js

@@ -33,8 +33,9 @@ const {
   getBrowserVersion
 } = BrowserDetection();
 
-// Apply a CIDR /28 format to the IP address
-const anonymizeIPAddress = (localIp) => anonymize(localIp);
+// Apply a CIDR /28 format to the IPV4 and /96 to the IPV6 addresses
+// For reference : https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing
+const anonymizeIPAddress = (localIp) => anonymize(localIp, 28, 96);
 
 const triggerTimers = ({event, meeting, data}) => {
   switch (event) {

package/test/unit/spec/locus-info/index.js

@@ -7,13 +7,15 @@ import MockWebex from '@webex/test-helper-mock-webex';
 import Meetings from '@webex/plugin-meetings';
 import LocusInfo from '@webex/plugin-meetings/src/locus-info';
 import SelfUtils from '@webex/plugin-meetings/src/locus-info/selfUtils';
+import InfoUtils from '@webex/plugin-meetings/src/locus-info/infoUtils';
 import LocusDeltaParser from '@webex/plugin-meetings/src/locus-info/parser';
 
 import {
   LOCUSINFO,
   RECORDING_STATE,
   LOCUSEVENT,
-  EVENTS
+  EVENTS,
+  DISPLAY_HINTS
 } from '../../../../src/constants';
 
 import {self, selfWithInactivity} from './selfConstant';
@@ -587,6 +589,8 @@ describe('plugin-meetings', () => {
 
     describe('#updateMeetingInfo', () => {
       let meetingInfo;
+      let getInfosSpy;
+      let getRolesSpy;
 
       beforeEach('setup meeting info', () => {
         meetingInfo = {
@@ -595,8 +599,14 @@ describe('plugin-meetings', () => {
             moderator: []
           }
         };
+        getInfosSpy = sinon.spy(InfoUtils, 'getInfos');
+        getRolesSpy = sinon.spy(SelfUtils, 'getRoles');
       });
 
+      afterEach(() => {
+        getRolesSpy.restore();
+        getInfosSpy.restore();
+      });
 
       it('should trigger MEETING_LOCKED/UNLOCKED when meeting gets locked/unlocked', () => {
         const meetingInfoLocked = cloneDeep(meetingInfo);
@@ -630,6 +640,82 @@ describe('plugin-meetings', () => {
         LOCUSINFO.EVENTS.MEETING_UNLOCKED,
         meetingInfoUnlocked);
       });
+
+      const checkMeetingInfoUpdatedCalled = (expected) => {
+        const expectedArgs = [locusInfo.emitScoped, {
+          file: 'locus-info',
+          function: 'updateMeetingInfo'
+        },
+        LOCUSINFO.EVENTS.MEETING_INFO_UPDATED,
+        {info: locusInfo.parsedLocus.info, self}];
+
+        if (expected) {
+          assert.calledWith(...expectedArgs);
+        }
+        else {
+          assert.neverCalledWith(...expectedArgs);
+        }
+        locusInfo.emitScoped.resetHistory();
+      };
+
+      it('emits MEETING_INFO_UPDATED if the info changes', () => {
+        const initialInfo = cloneDeep(meetingInfo);
+
+        locusInfo.emitScoped = sinon.stub();
+
+        // set the info initially as locusInfo.info starts as undefined
+        locusInfo.updateMeetingInfo(initialInfo, self);
+
+        // since it was initially undefined, this should trigger the event
+        checkMeetingInfoUpdatedCalled(true);
+
+        const newInfo = cloneDeep(meetingInfo);
+
+        newInfo.displayHints.coHost = [DISPLAY_HINTS.LOCK_CONTROL_LOCK];
+
+        // Updating with different info should trigger the event
+        locusInfo.updateMeetingInfo(newInfo, self);
+
+        checkMeetingInfoUpdatedCalled(true);
+
+        // update it with the same info
+        locusInfo.updateMeetingInfo(newInfo, self);
+
+        // since the info is the same it should not call trigger the event
+        checkMeetingInfoUpdatedCalled(false);
+      });
+
+      it('gets roles from self if available', () => {
+        const initialInfo = cloneDeep(meetingInfo);
+
+        const parsedLocusInfo = cloneDeep(locusInfo.parsedLocus.info);
+
+        locusInfo.updateMeetingInfo(initialInfo, self);
+
+        assert.calledWith(getRolesSpy, self);
+        assert.calledWith(
+          getInfosSpy,
+          parsedLocusInfo, initialInfo, ['PRESENTER']
+        );
+      });
+
+      it('gets roles from parsedLocus if self not passed in', () => {
+        const initialInfo = cloneDeep(meetingInfo);
+
+        locusInfo.parsedLocus.self = {
+          roles: ['MODERATOR', 'COHOST']
+        };
+
+        const parsedLocusInfo = cloneDeep(locusInfo.parsedLocus.info);
+
+        locusInfo.updateMeetingInfo(initialInfo);
+
+        assert.neverCalledWith(getRolesSpy, self);
+        assert.calledWith(
+          getInfosSpy,
+          parsedLocusInfo, initialInfo, ['MODERATOR', 'COHOST']
+        );
+      });
     });
 
     describe('#LocusDeltaEvents', () => {

package/test/unit/spec/locus-info/infoUtils.js

@@ -0,0 +1,122 @@
+import {assert} from '@webex/test-helper-chai';
+import Sinon from 'sinon';
+
+import InfoUtils from '@webex/plugin-meetings/src/locus-info/infoUtils';
+
+
+describe('plugin-meetings', () => {
+  describe('infoUtils', () => {
+    const info = {
+      displayHints: {
+        moderator: [
+          'HINT_1',
+          'HINT_2'
+        ],
+        joined: ['HINT_3'],
+        coHost: ['HINT_4']
+      }
+    };
+
+    describe('getInfos', () => {
+      it('passes roles to parse', () => {
+        const parseSpy = Sinon.spy(InfoUtils, 'parse');
+
+        const roles = ['COHOST', 'MODERATOR'];
+
+        InfoUtils.getInfos({}, info, roles);
+
+        assert.calledWith(parseSpy, info, roles);
+      });
+    });
+
+    describe('parse', () => {
+      it('only gives includes display hints when user has the correct role', () => {
+        assert.deepEqual(InfoUtils.parse(info, ['MODERATOR']), {
+          policy: {HINT_3: true},
+          moderator: {HINT_1: true, HINT_2: true},
+          coHost: {HINT_4: true},
+          userDisplayHints: ['HINT_3', 'HINT_1', 'HINT_2']
+        });
+
+        assert.deepEqual(InfoUtils.parse(info, ['COHOST']), {
+          policy: {HINT_3: true},
+          moderator: {HINT_1: true, HINT_2: true},
+          coHost: {HINT_4: true},
+          userDisplayHints: ['HINT_3', 'HINT_4']
+        });
+
+        assert.deepEqual(InfoUtils.parse(info, []), {
+          policy: {HINT_3: true},
+          moderator: {HINT_1: true, HINT_2: true},
+          coHost: {HINT_4: true},
+          userDisplayHints: ['HINT_3']
+        });
+      });
+    });
+
+    describe('parseDisplayHintsSection', () => {
+      it('returns the correct hints', () => {
+        assert.deepEqual(
+          InfoUtils.parseDisplayHintSection(info, 'moderator'),
+          {HINT_1: true, HINT_2: true}
+        );
+
+        assert.deepEqual(
+          InfoUtils.parseDisplayHintSection(info, 'joined'),
+          {HINT_3: true}
+        );
+
+        assert.deepEqual(
+          InfoUtils.parseDisplayHintSection({}, 'joined'),
+          {}
+        );
+
+        assert.deepEqual(
+          InfoUtils.parseDisplayHintSection({displayHints: {}}, 'joined'),
+          {}
+        );
+
+        assert.deepEqual(
+          InfoUtils.parseDisplayHintSection({displayHints: {joined: {}}}, 'joined'),
+          {}
+        );
+      });
+    });
+
+    describe('parse display hint tests', () => {
+      let parseDisplayHintSectionSpy;
+
+      beforeEach(() => {
+        parseDisplayHintSectionSpy = Sinon.spy(InfoUtils, 'parseDisplayHintSection');
+      });
+
+      afterEach(() => {
+        parseDisplayHintSectionSpy.restore();
+      });
+
+      it('parseModerator calls parseDisplayHintSection correctly and returns the result', () => {
+        const result = InfoUtils.parseModerator(info);
+
+        assert.calledWith(parseDisplayHintSectionSpy, info, 'moderator');
+
+        assert.deepEqual(result, parseDisplayHintSectionSpy.firstCall.returnValue);
+      });
+
+      it('parsePolicy calls parseDisplayHintSection correctly and returns the result', () => {
+        const result = InfoUtils.parsePolicy(info);
+
+        assert.calledWith(parseDisplayHintSectionSpy, info, 'joined');
+
+        assert.deepEqual(result, parseDisplayHintSectionSpy.firstCall.returnValue);
+      });
+
+      it('parseCoHost calls parseDisplayHintSection correctly and returns the result', () => {
+        const result = InfoUtils.parseCoHost(info);
+
+        assert.calledWith(parseDisplayHintSectionSpy, info, 'coHost');
+
+        assert.deepEqual(result, parseDisplayHintSectionSpy.firstCall.returnValue);
+      });
+    });
+  });
+});

package/test/unit/spec/locus-info/selfUtils.js

@@ -0,0 +1,43 @@
+import {assert} from '@webex/test-helper-chai';
+import Sinon from 'sinon';
+
+import SelfUtils from '@webex/plugin-meetings/src/locus-info/selfUtils';
+
+import {self} from './selfConstant';
+
+describe('plugin-meetings', () => {
+  describe('selfUtils', () => {
+    describe('parse', () => {
+      it('parse calls getRoles and returns the resulting roles', () => {
+        const getRolesSpy = Sinon.spy(SelfUtils, 'getRoles');
+
+        const parsedSelf = SelfUtils.parse(self);
+
+        assert.calledWith(getRolesSpy, self);
+
+        assert.deepEqual(parsedSelf.roles, ['PRESENTER']);
+      });
+    });
+
+    describe('getRoles', () => {
+      it('get roles works', () => {
+        assert.deepEqual(SelfUtils.getRoles(self), ['PRESENTER']);
+
+        assert.deepEqual(SelfUtils.getRoles({
+          controls: {
+            role: {roles: [{type: 'SOME_ARBITRARY_ROLE', hasRole: true}]}
+          }
+        }), ['SOME_ARBITRARY_ROLE']);
+
+        assert.deepEqual(SelfUtils.getRoles({
+          controls: {
+            role: {roles: [{type: 'SOME_ARBITRARY_ROLE', hasRole: false}]}
+          }
+        }), []);
+
+        assert.deepEqual(SelfUtils.getRoles({}), []);
+        assert.deepEqual(SelfUtils.getRoles(), []);
+      });
+    });
+  });
+});