fix(RtxModifier.spec and SDPUtil.spec): random failures

Fixes random tests failures after frameworks upgrade.

modules/xmpp/RtxModifier.spec.js

 /* eslint-disable max-len*/
-/* eslint-disable no-invalid-this */
 import RtxModifier from './RtxModifier.js';
-import * as SampleSdpStrings from './SampleSdpStrings.js';
+import { default as SampleSdpStrings } from './SampleSdpStrings.js';
 import * as transform from 'sdp-transform';
 import SDPUtil from './SDPUtil';
 
 }
 
 describe('RtxModifier', () => {
-    beforeEach(function() {
-        this.rtxModifier = new RtxModifier();
-        this.transform = transform;
-        this.SDPUtil = SDPUtil;
+    let rtxModifier;
+
+    beforeEach(() => {
+        rtxModifier = new RtxModifier();
     });
 
     describe('modifyRtxSsrcs', () => {
         describe('when given an sdp with a single video ssrc', () => {
-            beforeEach(function() {
-                this.singleVideoSdp = SampleSdpStrings.plainVideoSdp;
-                this.primaryVideoSsrc = getPrimaryVideoSsrc(this.singleVideoSdp);
+            let primaryVideoSsrc, singleVideoSdp;
+
+            beforeEach(() => {
+                singleVideoSdp = SampleSdpStrings.plainVideoSdp;
+                primaryVideoSsrc = getPrimaryVideoSsrc(singleVideoSdp);
             });
-            it('should add a single rtx ssrc', function() {
+            it('should add a single rtx ssrc', () => {
                 // Call rtxModifier.modifyRtxSsrcs with an sdp that contains a single video
                 //  ssrc.  The returned sdp should have an rtx ssrc and an fid group.
-                const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+                const newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(singleVideoSdp));
                 const newSdp = transform.parse(newSdpStr);
                 const newPrimaryVideoSsrc = getPrimaryVideoSsrc(newSdp);
 
-                expect(newPrimaryVideoSsrc).toEqual(this.primaryVideoSsrc);
+                expect(newPrimaryVideoSsrc).toEqual(primaryVideoSsrc);
 
                 // Should now have an rtx ssrc as well
                 expect(numVideoSsrcs(newSdp)).toEqual(2);
                 const fidGroup = fidGroups[0];
                 const fidGroupPrimarySsrc = SDPUtil.parseGroupSsrcs(fidGroup)[0];
 
-                expect(fidGroupPrimarySsrc).toEqual(this.primaryVideoSsrc);
+                expect(fidGroupPrimarySsrc).toEqual(primaryVideoSsrc);
             });
 
-            it('should re-use the same rtx ssrc for a primary ssrc it\'s seen before', function() {
+            it('should re-use the same rtx ssrc for a primary ssrc it\'s seen before', () => {
                 // Have rtxModifier generate an rtx ssrc via modifyRtxSsrcs.  Then call it again
                 //  with the same primary ssrc in the sdp (but no rtx ssrc).  It should use
                 //  the same rtx ssrc as before.
-                let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+                let newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(singleVideoSdp));
                 let newSdp = transform.parse(newSdpStr);
 
                 let fidGroup = getVideoGroups(newSdp, 'FID')[0];
                 const fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
 
                 // Now pass the original sdp through again
-                newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+                newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(singleVideoSdp));
                 newSdp = transform.parse(newSdpStr);
                 fidGroup = getVideoGroups(newSdp, 'FID')[0];
                 const newFidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
                 expect(newFidGroupRtxSsrc).toEqual(fidGroupRtxSsrc);
             });
 
-            it('should NOT re-use the same rtx ssrc for a primary ssrc it\'s seen before if the cache has been cleared', function() {
+            it('should NOT re-use the same rtx ssrc for a primary ssrc it\'s seen before if the cache has been cleared', () => {
                 // Call modifyRtxSsrcs to generate an rtx ssrc
                 // Clear the rtxModifier cache
                 // Call modifyRtxSsrcs to generate an rtx ssrc again with the same primary ssrc
                 // --> We should get a different rtx ssrc
-                let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+                let newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(singleVideoSdp));
                 let newSdp = transform.parse(newSdpStr);
 
                 let fidGroup = getVideoGroups(newSdp, 'FID')[0];
                 const fidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
 
-                this.rtxModifier.clearSsrcCache();
+                rtxModifier.clearSsrcCache();
 
                 // Now pass the original sdp through again
-                newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+                newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(singleVideoSdp));
                 newSdp = transform.parse(newSdpStr);
                 fidGroup = getVideoGroups(newSdp, 'FID')[0];
                 const newFidGroupRtxSsrc = SDPUtil.parseGroupSsrcs(fidGroup)[1];
                 expect(newFidGroupRtxSsrc).not.toEqual(fidGroupRtxSsrc);
             });
 
-            it('should use the rtx ssrc from the cache when the cache has been manually set', function() {
+            it('should use the rtx ssrc from the cache when the cache has been manually set', () => {
                 // Manually set an rtx ssrc mapping in the cache
                 // Call modifyRtxSsrcs
                 // -->The rtx ssrc used should be the one we set
                 const forcedRtxSsrc = 123456;
                 const ssrcCache = new Map();
 
-                ssrcCache.set(this.primaryVideoSsrc, forcedRtxSsrc);
-                this.rtxModifier.setSsrcCache(ssrcCache);
-                const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.singleVideoSdp));
+                ssrcCache.set(primaryVideoSsrc, forcedRtxSsrc);
+                rtxModifier.setSsrcCache(ssrcCache);
+                const newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(singleVideoSdp));
                 const newSdp = transform.parse(newSdpStr);
 
                 const fidGroup = getVideoGroups(newSdp, 'FID')[0];
         });
 
         describe('when given an sdp with multiple video ssrcs', () => {
-            beforeEach(function() {
-                this.multipleVideoSdp = SampleSdpStrings.simulcastSdp;
-                this.primaryVideoSsrcs = getPrimaryVideoSsrcs(this.multipleVideoSdp);
+            let multipleVideoSdp, primaryVideoSsrcs;
+
+            beforeEach(() => {
+                multipleVideoSdp = SampleSdpStrings.simulcastSdp;
+                primaryVideoSsrcs = getPrimaryVideoSsrcs(multipleVideoSdp);
             });
 
-            it('should add rtx ssrcs for all of them', function() {
+            it('should add rtx ssrcs for all of them', () => {
                 // Call rtxModifier.modifyRtxSsrcs with an sdp that contains multiple video
                 //  ssrcs.  The returned sdp should have an rtx ssrc and an fid group for all of them.
-                const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+                const newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(multipleVideoSdp));
                 const newSdp = transform.parse(newSdpStr);
                 const newPrimaryVideoSsrcs = getPrimaryVideoSsrcs(newSdp);
 
-                expect(newPrimaryVideoSsrcs).toEqual(this.primaryVideoSsrcs);
+                expect(newPrimaryVideoSsrcs).toEqual(primaryVideoSsrcs);
 
                 // Should now have rtx ssrcs as well
-                expect(numVideoSsrcs(newSdp)).toEqual(this.primaryVideoSsrcs.length * 2);
+                expect(numVideoSsrcs(newSdp)).toEqual(primaryVideoSsrcs.length * 2);
 
                 // Should now have FID groups
                 const fidGroups = getVideoGroups(newSdp, 'FID');
 
-                expect(fidGroups.length).toEqual(this.primaryVideoSsrcs.length);
+                expect(fidGroups.length).toEqual(primaryVideoSsrcs.length);
                 fidGroups.forEach(fidGroup => {
                     const fidGroupPrimarySsrc = SDPUtil.parseGroupSsrcs(fidGroup)[0];
 
-                    expect(this.primaryVideoSsrcs.indexOf(fidGroupPrimarySsrc)).not.toEqual(-1);
+                    expect(primaryVideoSsrcs.indexOf(fidGroupPrimarySsrc)).not.toEqual(-1);
                 });
             });
 
-            it('should re-use the same rtx ssrcs for any primary ssrc it\'s seen before', function() {
+            it('should re-use the same rtx ssrcs for any primary ssrc it\'s seen before', () => {
                 // Have rtxModifier generate an rtx ssrc via modifyRtxSsrcs.  Then call it again
                 //  with the same primary ssrc in the sdp (but no rtx ssrc).  It should use
                 //  the same rtx ssrc as before.
-                let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+                let newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(multipleVideoSdp));
                 let newSdp = transform.parse(newSdpStr);
 
                 const rtxMapping = new Map();
                 });
 
                 // Now pass the original sdp through again and make sure we get the same mapping
-                newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+                newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(multipleVideoSdp));
                 newSdp = transform.parse(newSdpStr);
                 fidGroups = getVideoGroups(newSdp, 'FID');
                 fidGroups.forEach(fidGroup => {
                 });
             });
 
-            it('should NOT re-use the same rtx ssrcs for any primary ssrc it\'s seen before if the cache has been cleared', function() {
+            it('should NOT re-use the same rtx ssrcs for any primary ssrc it\'s seen before if the cache has been cleared', () => {
                 // Call modifyRtxSsrcs to generate an rtx ssrc
                 // Clear the rtxModifier cache
                 // Call modifyRtxSsrcs to generate rtx ssrcs again with the same primary ssrcs
                 // --> We should get different rtx ssrcs
-                let newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+                let newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(multipleVideoSdp));
                 let newSdp = transform.parse(newSdpStr);
 
                 const rtxMapping = new Map();
                     rtxMapping.set(fidGroupPrimarySsrc, fidGroupRtxSsrc);
                 });
 
-                this.rtxModifier.clearSsrcCache();
+                rtxModifier.clearSsrcCache();
 
                 // Now pass the original sdp through again and make sure we get the same mapping
-                newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+                newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(multipleVideoSdp));
                 newSdp = transform.parse(newSdpStr);
                 fidGroups = getVideoGroups(newSdp, 'FID');
                 fidGroups.forEach(fidGroup => {
                 });
             });
 
-            it('should use the rtx ssrcs from the cache when the cache has been manually set', function() {
+            it('should use the rtx ssrcs from the cache when the cache has been manually set', () => {
                 // Manually set an rtx ssrc mapping in the cache
                 // Call modifyRtxSsrcs
                 // -->The rtx ssrc used should be the one we set
                 const rtxMapping = new Map();
 
-                this.primaryVideoSsrcs.forEach(ssrc => {
+                primaryVideoSsrcs.forEach(ssrc => {
                     rtxMapping.set(ssrc, SDPUtil.generateSsrc());
                 });
-                this.rtxModifier.setSsrcCache(rtxMapping);
+                rtxModifier.setSsrcCache(rtxMapping);
 
-                const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(this.multipleVideoSdp));
+                const newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(multipleVideoSdp));
                 const newSdp = transform.parse(newSdpStr);
 
                 const fidGroups = getVideoGroups(newSdp, 'FID');
         });
 
         describe('when given an sdp with a flexfec stream', () => {
-            it('should not add rtx for the flexfec ssrc', function() {
+            it('should not add rtx for the flexfec ssrc', () => {
                 const flexFecSdp = SampleSdpStrings.flexFecSdp;
-                const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(flexFecSdp));
+                const newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(flexFecSdp));
                 const newSdp = transform.parse(newSdpStr);
                 const fidGroups = getVideoGroups(newSdp, 'FID');
 
         });
 
         describe('(corner cases)', () => {
-            it('should handle a recvonly video mline', function() {
+            it('should handle a recvonly video mline', () => {
                 const sdp = SampleSdpStrings.plainVideoSdp;
                 const videoMLine = sdp.media.find(m => m.type === 'video');
 
                 videoMLine.direction = 'recvonly';
-                const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
+                const newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(sdp));
 
-                expect(newSdpStr).toEqual(this.transform.write(sdp));
+                expect(newSdpStr).toEqual(transform.write(sdp));
             });
 
-            it('should handle a video mline with no video ssrcs', function() {
+            it('should handle a video mline with no video ssrcs', () => {
                 const sdp = SampleSdpStrings.plainVideoSdp;
                 const videoMLine = sdp.media.find(m => m.type === 'video');
 
                 videoMLine.ssrcs = [];
-                const newSdpStr = this.rtxModifier.modifyRtxSsrcs(this.transform.write(sdp));
+                const newSdpStr = rtxModifier.modifyRtxSsrcs(transform.write(sdp));
 
-                expect(newSdpStr).toEqual(this.transform.write(sdp));
+                expect(newSdpStr).toEqual(transform.write(sdp));
             });
         });
     });
 
     describe('stripRtx', () => {
         beforeEach(() => { }); // eslint-disable-line no-empty-function
-        it('should strip all rtx streams from an sdp with rtx', function() {
+        it('should strip all rtx streams from an sdp with rtx', () => {
             const sdpStr = transform.write(SampleSdpStrings.rtxVideoSdp);
-            const newSdpStr = this.rtxModifier.stripRtx(sdpStr);
+            const newSdpStr = rtxModifier.stripRtx(sdpStr);
             const newSdp = transform.parse(newSdpStr);
             const fidGroups = getVideoGroups(newSdp, 'FID');
 
             expect(fidGroups.length).toEqual(0);
             expect(numVideoSsrcs(newSdp)).toEqual(1);
         });
-        it('should do nothing to an sdp with no rtx', function() {
+        it('should do nothing to an sdp with no rtx', () => {
             const sdpStr = transform.write(SampleSdpStrings.plainVideoSdp);
-            const newSdpStr = this.rtxModifier.stripRtx(sdpStr);
+            const newSdpStr = rtxModifier.stripRtx(sdpStr);
 
             expect(newSdpStr).toEqual(sdpStr);
         });
     });
 });
 
-/* eslint-enable no-invalid-this */
 /* eslint-enable max-len*/

modules/xmpp/SDPUtil.spec.js

 import SDPUtil from './SDPUtil';
-import * as SampleSdpStrings from './SampleSdpStrings.js';
+import { default as SampleSdpStrings } from './SampleSdpStrings.js';
 
 describe('SDPUtil', () => {
     it('should parse an ice ufrag correctly', () => {

modules/xmpp/SampleSdpStrings.js

 // A full sdp string representing a client doing a single video stream with flexfec
 const flexFecSdpStr = baseSessionSdp + baseAudioMLineSdp + flexFecVideoMLineSdp + baseDataMLineSdp;
 
-export const simulcastSdp = transform.parse(simulcastSdpStr);
-export const simulcastRtxSdp = transform.parse(simulcastRtxSdpStr);
-export const plainVideoSdp = transform.parse(plainVideoSdpStr);
-export const rtxVideoSdp = transform.parse(rtxVideoSdpStr);
-export const multiCodecVideoSdp = transform.parse(multiCodecVideoSdpStr);
-export const flexFecSdp = transform.parse(flexFecSdpStr);
+export default {
+    get simulcastSdp() {
+        return transform.parse(simulcastSdpStr);
+    },
+
+    get simulcastRtxSdp() {
+        return transform.parse(simulcastRtxSdpStr);
+    },
+
+    get plainVideoSdp() {
+        return transform.parse(plainVideoSdpStr);
+    },
+
+    get rtxVideoSdp() {
+        return transform.parse(rtxVideoSdpStr);
+    },
+
+    get multiCodecVideoSdp() {
+        return transform.parse(multiCodecVideoSdpStr);
+    },
+
+    get flexFecSdp() {
+        return transform.parse(flexFecSdpStr);
+    }
+};
 
 /* eslint-enable max-len*/