@webex/plugin-meetings 3.0.0-beta.10 → 3.0.0-beta.104

package/test/unit/spec/meetings/utils.js

@@ -10,45 +10,51 @@ describe('plugin-meetings', () => {
           sites: [
             {
               siteUrl: 'site1-example.webex.com',
-              default: false
+              default: false,
             },
             {
               siteUrl: 'site2-example.webex.com',
-              default: false
+              default: false,
             },
             {
               siteUrl: 'go.webex.com',
-              default: true
+              default: true,
             },
             {
               siteUrl: 'site3-example.webex.com',
-              default: false
-            }
-          ]
+              default: false,
+            },
+          ],
         };
 
-        assert.equal(MeetingsUtil.parseDefaultSiteFromMeetingPreferences(userPreferences), 'go.webex.com');
+        assert.equal(
+          MeetingsUtil.parseDefaultSiteFromMeetingPreferences(userPreferences),
+          'go.webex.com'
+        );
       });
 
-      it('should work fine if no default true site', () => {
+      it('should take the first site if none are default', () => {
         const userPreferences = {
           sites: [
             {
               siteUrl: 'site1-example.webex.com',
-              default: false
+              default: false,
             },
             {
               siteUrl: 'site2-example.webex.com',
-              default: false
+              default: false,
             },
             {
               siteUrl: 'site3-example.webex.com',
-              default: false
-            }
+              default: false,
+            },
           ],
         };
 
-        assert.equal(MeetingsUtil.parseDefaultSiteFromMeetingPreferences(userPreferences), '');
+        assert.equal(
+          MeetingsUtil.parseDefaultSiteFromMeetingPreferences(userPreferences),
+          'site1-example.webex.com'
+        );
       });
 
       it('should work fine if sites an empty array', () => {
@@ -59,6 +65,149 @@ describe('plugin-meetings', () => {
         assert.equal(MeetingsUtil.parseDefaultSiteFromMeetingPreferences(userPreferences), '');
       });
     });
+
+    describe('#getThisDevice', () => {
+      it('return null if no devices in self', () => {
+        const newLocus = {};
+        assert.equal(MeetingsUtil.getThisDevice(newLocus, '123'), null);
+      });
+      it('return null if no matched device in self', () => {
+        const newLocus = {
+          self: {
+            devices: [{state: 'JOINED', url: '456'}]
+          }
+        };
+        assert.equal(MeetingsUtil.getThisDevice(newLocus, '123'), null);
+      });
+      it('return the device match with current device', () => {
+        const newLocus = {
+          self: {
+            devices: [{state: 'JOINED', url: '123'}]
+          }
+        };
+        assert.deepEqual(MeetingsUtil.getThisDevice(newLocus, '123'), {state: 'JOINED', url: '123'});
+      })
+    });
+
+    describe('#isBreakoutLocusDTO', () => {
+      it('returns false is no breakout in locus.controls', () => {
+        const newLocus = {
+          controls: {}
+        };
+
+        assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), false);
+      });
+
+      it('returns is breakout locus DTO if sessionType is BREAKOUT', () => {
+        const newLocus = {
+          controls: {
+            breakout: {
+              sessionType: 'BREAKOUT',
+            },
+          },
+        };
+        assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), true);
+      });
+
+      it('returns is not breakout locus DTO if sessionType is MAIN', () => {
+        const newLocus = {
+          controls: {
+            breakout: {
+              sessionType: 'MAIN',
+            },
+          },
+        };
+        assert.equal(MeetingsUtil.isBreakoutLocusDTO(newLocus), false);
+      });
+    });
+
+    describe('#joinedOnThisDevice', () => {
+      it('return false if no devices in self', () => {
+        const newLocus = {};
+        assert.equal(MeetingsUtil.joinedOnThisDevice(null, newLocus, '123'), false);
+      });
+      it('return true if joined on this device', () => {
+        const newLocus = {
+          self: {
+            devices: [{state: 'JOINED', correlationId: '111', url: '123'}]
+          }
+        };
+        const meeting = {
+          correlationId: '111'
+        };
+
+        assert.equal(MeetingsUtil.joinedOnThisDevice(meeting, newLocus, '123'), true);
+      });
+      it('return true if selfMoved on this device', () => {
+        const newLocus = {
+          self: {
+            devices: [{state: 'LEFT', reason: 'MOVED', correlationId: '111', url: '123'}]
+          }
+        };
+        const meeting = {
+          correlationId: '111'
+        };
+
+        assert.equal(MeetingsUtil.joinedOnThisDevice(meeting, newLocus, '123'), true);
+      });
+    });
   });
-});
 
+  describe('#isValidBreakoutLocus', () => {
+    it('returns false if is not breakout locus', () => {
+      const newLocus = {
+        controls: {}
+      };
+
+      assert.equal(MeetingsUtil.isValidBreakoutLocus(newLocus), false);
+    });
+
+    it('returns false if fullState is inactive', () => {
+      const newLocus = {
+        controls: {
+          breakout: {
+            sessionType: 'BREAKOUT',
+          },
+        },
+        fullState: {
+          state: 'INACTIVE'
+        }
+      };
+      assert.equal(MeetingsUtil.isValidBreakoutLocus(newLocus), false);
+    });
+
+    it('returns false if self is not joined', () => {
+      const newLocus = {
+        controls: {
+          breakout: {
+            sessionType: 'BREAKOUT',
+          },
+        },
+        fullState: {
+          state: 'ACTIVE'
+        },
+        self: {
+          state: 'LEFT'
+        }
+      };
+      assert.equal(MeetingsUtil.isValidBreakoutLocus(newLocus), false);
+    });
+
+    it('returns true if self is JOINED and fullState is active', () => {
+      const newLocus = {
+        controls: {
+          breakout: {
+            sessionType: 'BREAKOUT',
+          },
+        },
+        fullState: {
+          state: 'ACTIVE'
+        },
+        self: {
+          state: 'JOINED'
+        }
+      };
+      assert.equal(MeetingsUtil.isValidBreakoutLocus(newLocus), true);
+    });
+  });
+});

package/test/unit/spec/member/index.js

@@ -4,7 +4,6 @@ import {assert} from '@webex/test-helper-chai';
 import MemberUtil from '@webex/plugin-meetings/src/member/util';
 import Member from '@webex/plugin-meetings/src/member';
 
-
 describe('member', () => {
   afterEach(() => {
     sinon.restore();
@@ -20,4 +19,28 @@ describe('member', () => {
 
     assert.calledOnceWithExactly(MemberUtil.isHandRaised, participant);
   });
+
+  describe('roles', () => {
+    it('checks that processParticipant calls processRoles', () => {
+      const participant = {};
+
+      const member = new Member({});
+  
+      sinon.spy(member, 'processRoles');
+      member.processParticipant(participant);
+  
+      assert.calledOnceWithExactly(member.processRoles, participant);
+    });
+
+    it('checks that processRoles calls extractControlRoles', () => {
+      const participant = {};
+
+      const member = new Member({});
+  
+      sinon.spy(MemberUtil, 'extractControlRoles');
+      member.processParticipant(participant);
+  
+      assert.calledOnceWithExactly(MemberUtil.extractControlRoles, participant);
+    });
+  })
 });

package/test/unit/spec/member/util.js

@@ -1,50 +1,377 @@
 import {assert} from '@webex/test-helper-chai';
-
 import MemberUtil from '@webex/plugin-meetings/src/member/util';
+import { ServerRoles } from '../../../../src/member/types';
 
+describe('plugin-meetings', () => {
+  describe('isHandRaised', () => {
+    it('throws error when there is no participant', () => {
+      assert.throws(() => {
+        MemberUtil.isHandRaised();
+      }, 'Raise hand could not be processed, participant is undefined.');
+    });
+  
+    it('returns false when controls is not there', () => {
+      const participant = {};
+  
+      assert.isFalse(MemberUtil.isHandRaised(participant));
+    });
+  
+    it('returns false when hand is not there in controls', () => {
+      const participant = {
+        controls: {},
+      };
+  
+      assert.isFalse(MemberUtil.isHandRaised(participant));
+    });
+  
+    it('returns true when hand raised is true', () => {
+      const participant = {
+        controls: {
+          hand: {
+            raised: true,
+          },
+        },
+      };
+  
+      assert.isTrue(MemberUtil.isHandRaised(participant));
+    });
+  
+    it('returns false when hand raised is false', () => {
+      const participant = {
+        controls: {
+          hand: {
+            raised: false,
+          },
+        },
+      };
+  
+      assert.isFalse(MemberUtil.isHandRaised(participant));
+    });
+  });
 
-describe('isHandRaised', () => {
-  it('throws error when there is no participant', () => {
-    assert.throws(() => {
-      MemberUtil.isHandRaised();
-    }, 'Raise hand could not be processed, participant is undefined.');
+  describe('MemberUtil.extractControlRoles', () => {
+    it('happy path extract control roles', () => {
+      const participant = {
+        controls: {
+          role: {
+            roles: [
+              {type: 'PRESENTER', hasRole: true},
+              {type: 'COHOST', hasRole: true},
+              {type: 'MODERATOR', hasRole: true},
+            ]
+          }
+        }
+      }
+
+      assert.deepEqual(MemberUtil.extractControlRoles(participant), {cohost: true, moderator: true, presenter: true});
+    });
   });
 
-  it('returns false when controls is not there', () => {
-    const participant = {};
+  describe('MemberUtil.getControlsRoles', () => {
+    it('getControlsRoles', () => {
+      const participant = {
+        controls: {
+          role: {
+            roles: [
+              {type: 'PRESENTER', hasRole: true},
+            ]
+          }
+        }
+      }
 
-    assert.isFalse(MemberUtil.isHandRaised(participant));
+      assert.deepEqual(MemberUtil.getControlsRoles(participant), [{type: 'PRESENTER', hasRole: true}]);
+    });
   });
 
-  it('returns false when hand is not there in controls', () => {
-    const participant = {
-      controls: {}
-    };
+  describe('MemberUtil.hasRole', () => {
+    describe('PRESENTER', () => {
+      it('getControlsRoles PRESENTER true', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'PRESENTER', hasRole: true},
+              ]
+            }
+          }
+        }
+  
+        assert.isTrue(MemberUtil.hasRole(participant, ServerRoles.Presenter));
+      });
+
+      it('getControlsRoles PRESENTER false', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'PRESENTER', hasRole: false},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasRole(participant, ServerRoles.Presenter));
+      });
+
+      it('getControlsRoles PRESENTER undefined', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasRole(participant, ServerRoles.Presenter));
+      });
+    })
+
+    describe('MODERATOR', () => {
+      it('getControlsRoles MODERATOR true', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'MODERATOR', hasRole: true},
+              ]
+            }
+          }
+        }
+  
+        assert.isTrue(MemberUtil.hasRole(participant, ServerRoles.Moderator));
+      });
+
+      it('getControlsRoles MODERATOR false', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'MODERATOR', hasRole: false},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasRole(participant, ServerRoles.Moderator));
+      });
+
+      it('getControlsRoles MODERATOR undefined', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasRole(participant, ServerRoles.Moderator));
+      });
+    })
+
+    describe('COHOST', () => {
+      it('getControlsRoles COHOST true', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'COHOST', hasRole: true},
+              ]
+            }
+          }
+        }
+  
+        assert.isTrue(MemberUtil.hasRole(participant, ServerRoles.Cohost));
+      });
+
+      it('getControlsRoles COHOST false', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'COHOST', hasRole: false},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasRole(participant, ServerRoles.Cohost));
+      });
 
-    assert.isFalse(MemberUtil.isHandRaised(participant));
+      it('getControlsRoles COHOST undefined', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasRole(participant, ServerRoles.Cohost));
+      });
+    })
   });
 
-  it('returns true when hand raised is true', () => {
-    const participant = {
-      controls: {
-        hand: {
-          raised: true
-        },
-      }
-    };
+  describe('MemberUtil.is<Role>', () => {
+    describe('PRESENTER', () => {
+      it('getControlsRoles PRESENTER true', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'PRESENTER', hasRole: true},
+              ]
+            }
+          }
+        }
+  
+        assert.isTrue(MemberUtil.hasPresenter(participant, ServerRoles.Presenter));
+      });
+
+      it('getControlsRoles PRESENTER false', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'PRESENTER', hasRole: false},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasPresenter(participant));
+      });
+
+      it('getControlsRoles PRESENTER undefined', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasPresenter(participant));
+      });
+    })
+
+    describe('MODERATOR', () => {
+      it('getControlsRoles MODERATOR true', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'MODERATOR', hasRole: true},
+              ]
+            }
+          }
+        }
+  
+        assert.isTrue(MemberUtil.hasModerator(participant));
+      });
+
+      it('getControlsRoles MODERATOR false', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'MODERATOR', hasRole: false},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasModerator(participant));
+      });
+
+      it('getControlsRoles MODERATOR undefined', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasModerator(participant));
+      });
+    })
 
-    assert.isTrue(MemberUtil.isHandRaised(participant));
+    describe('COHOST', () => {
+      it('getControlsRoles COHOST true', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'COHOST', hasRole: true},
+              ]
+            }
+          }
+        }
+  
+        assert.isTrue(MemberUtil.hasCohost(participant));
+      });
+
+      it('getControlsRoles COHOST false', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {type: 'COHOST', hasRole: false},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasCohost(participant));
+      });
+
+      it('getControlsRoles COHOST undefined', () => {
+        const participant = {
+          controls: {
+            role: {
+              roles: [
+                {},
+              ]
+            }
+          }
+        }
+  
+        assert.isFalse(MemberUtil.hasCohost(participant));
+      });
+    })
   });
 
-  it('returns false when hand raised is false', () => {
-    const participant = {
-      controls: {
-        hand: {
-          raised: false
-        },
-      }
-    };
+  describe('MemberUtil.isBreakoutsSupported', () => {
+    it('throws error when there is no participant', () => {
+      assert.throws(() => {
+        MemberUtil.isBreakoutsSupported();
+      }, 'Breakout support could not be processed, participant is undefined.');
+    });
+
+    it('returns true when hand breakouts are supported', () => {
+      const participant = {
+        doesNotSupportBreakouts: false
+      };
+
+      assert.isTrue(MemberUtil.isBreakoutsSupported(participant));
+    });
+
+    it('returns false when hand breakouts are not supported', () => {
+      const participant = {
+        doesNotSupportBreakouts: true
+      };
 
-    assert.isFalse(MemberUtil.isHandRaised(participant));
+      assert.isFalse(MemberUtil.isBreakoutsSupported(participant));
+    });
   });
 });