@webex/plugin-meetings 3.12.0-next.9 → 3.12.0-task-refactor.1

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

@@ -299,55 +299,5 @@ describe('plugin-meetings', () => {
       const sdp2 = 'v=0\r\no=HOMER 0 1 IN IP4 23.89.67.81\r\ns=-\r\nc=IN IP4 23.89.67.81\r\nb=TIAS:128000\r\nt=0 0\r\na=ice-lite\r\n'
       assert.equal(MeetingsUtil.getMediaServer(sdp2), 'homer');
     });
-  });
-
-  describe('#getCorrelationIdForDevice', () => {
-    it('should return correlationId if device with matching url is found', () => {
-      const locusSelf = {
-        devices: [
-          {url: 'deviceUrl1', correlationId: 'correlationId1'},
-          {url: 'deviceUrl2', correlationId: 'correlationId2'},
-        ],
-      };
-
-      const correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', locusSelf);
-      assert.equal(correlationId, 'correlationId1');
-    });
-
-    it('should return false if no device with matching url is found', () => {
-      const locusSelf = {
-        devices: [
-          {url: 'deviceUrl1', correlationId: 'correlationId1'},
-          {url: 'deviceUrl2', correlationId: 'correlationId2'},
-        ],
-      };
-
-      const correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl3', locusSelf);
-      assert.equal(correlationId, false);
-    });
-
-    it('should return false if device with matching url has no correlationId', () => {
-      const locusSelf = {
-        devices: [{url: 'deviceUrl1'}, {url: 'deviceUrl2', correlationId: 'correlationId2'}],
-      };
-
-      const correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', locusSelf);
-      assert.equal(correlationId, false);
-    });
-
-    it('should return false if locusSelf has no devices', () => {
-      const locusSelf = {};
-
-      const correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', locusSelf);
-      assert.equal(correlationId, false);
-    });
-
-    it('should return false if locusSelf is null or undefined', () => {
-      let correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', null);
-      assert.equal(correlationId, false);
-
-      correlationId = MeetingsUtil.getCorrelationIdForDevice('deviceUrl1', undefined);
-      assert.equal(correlationId, false);
-    });
-  });
+  })
 });

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

@@ -18,7 +18,6 @@ describe('member', () => {
     assert.exists(member.supportsBreakouts);
     assert.exists(member.supportLiveAnnotation);
     assert.exists(member.canReclaimHost);
-    assert.exists(member.canApproveAIEnablement);
   });
 
   describe('roles', () => {
@@ -48,24 +47,17 @@ describe('member', () => {
     it('checks that processParticipant calls canReclaimHost', () => {
       sinon.spy(MemberUtil, 'canReclaimHost');
       member.processParticipant(participant);
-
+  
       assert.calledOnceWithExactly(MemberUtil.canReclaimHost, participant);
     });
 
     it('checks that processParticipant calls isPresenterAssignmentProhibited', () => {
       sinon.spy(MemberUtil, 'isPresenterAssignmentProhibited');
       member.processParticipant(participant);
-
+  
       assert.calledOnceWithExactly(MemberUtil.isPresenterAssignmentProhibited, participant);
     });
-
-    it('checks that processParticipant calls canApproveAIEnablement', () => {
-      sinon.spy(MemberUtil, 'canApproveAIEnablement');
-      member.processParticipant(participant);
-
-      assert.calledOnceWithExactly(MemberUtil.canApproveAIEnablement, participant);
-    });
-  });
+  })
 
   describe('#processMember', () => {
     it('checks that processMember calls isRemovable', () => {
@@ -88,21 +80,5 @@ describe('member', () => {
 
       assert.calledOnceWithExactly(MemberUtil.extractMediaStatus, participant);
     });
-  });
-
-  describe('canApproveAIEnablement integration', () => {
-    it('sets canApproveAIEnablement to the value returned by MemberUtil.canApproveAIEnablement', () => {
-      const testParticipant = {controls: {}, status: {}};
-
-      sinon.stub(MemberUtil, 'canApproveAIEnablement').returns(true);
-      const memberWithTrue = new Member(testParticipant);
-      assert.isTrue(memberWithTrue.canApproveAIEnablement);
-
-      MemberUtil.canApproveAIEnablement.restore();
-
-      sinon.stub(MemberUtil, 'canApproveAIEnablement').returns(false);
-      const memberWithFalse = new Member(testParticipant);
-      assert.isFalse(memberWithFalse.canApproveAIEnablement);
-    });
-  });
+  })
 });

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

@@ -82,46 +82,6 @@ describe('plugin-meetings', () => {
     });
   });
 
-  describe('MemberUtil.canApproveAIEnablement', () => {
-    it('returns false when there is no participant', () => {
-      assert.isFalse(MemberUtil.canApproveAIEnablement());
-    });
-
-    it('returns false when there is null participant', () => {
-      assert.isFalse(MemberUtil.canApproveAIEnablement(null));
-    });
-
-    it('returns true when attendeeRequestAiAssistantNotAllowed is false', () => {
-      const participant = {
-        attendeeRequestAiAssistantNotAllowed: false,
-      };
-
-      assert.isTrue(MemberUtil.canApproveAIEnablement(participant));
-    });
-
-    it('returns false when attendeeRequestAiAssistantNotAllowed is true', () => {
-      const participant = {
-        attendeeRequestAiAssistantNotAllowed: true,
-      };
-
-      assert.isFalse(MemberUtil.canApproveAIEnablement(participant));
-    });
-
-    it('returns true when attendeeRequestAiAssistantNotAllowed is undefined', () => {
-      const participant = {
-        attendeeRequestAiAssistantNotAllowed: undefined,
-      };
-
-      assert.isTrue(MemberUtil.canApproveAIEnablement(participant));
-    });
-
-    it('returns true when attendeeRequestAiAssistantNotAllowed is not present', () => {
-      const participant = {};
-
-      assert.isTrue(MemberUtil.canApproveAIEnablement(participant));
-    });
-  });
-
   describe('MemberUtil.extractControlRoles', () => {
     it('happy path extract control roles', () => {
       const participant = {
@@ -417,6 +377,7 @@ describe('plugin-meetings', () => {
       assert.isFalse(MemberUtil.isBrb(participant));
     });
 
+
     it('returns false when brb is not present', () => {
       const participant = {
         controls: {},
@@ -456,28 +417,29 @@ describe('plugin-meetings', () => {
     });
   });
 
-  describe('MemberUtil.isSupportsSingleUserAutoEndMeeting', () => {
-    it('throws an error when there is no participant', () => {
-      assert.throws(() => {
-        MemberUtil.isSupportsSingleUserAutoEndMeeting();
-      }, 'Single user auto end meeting support could not be processed, participant is undefined.');
-    });
+describe('MemberUtil.isSupportsSingleUserAutoEndMeeting', () => {
+  it('throws an error when there is no participant', () => {
+    assert.throws(() => {
+      MemberUtil.isSupportsSingleUserAutoEndMeeting();
+    }, 'Single user auto end meeting support could not be processed, participant is undefined.');
+  });
 
-    it('returns true when single user auto end meeting is supported', () => {
-      const participant = {
-        supportsSingleUserAutoEndMeeting: {},
-      };
-      assert.isTrue(MemberUtil.isSupportsSingleUserAutoEndMeeting(participant));
-    });
+  it('returns true when single user auto end meeting is supported', () => {
+    const participant = {
+      supportsSingleUserAutoEndMeeting: {},
+    };
+    assert.isTrue(MemberUtil.isSupportsSingleUserAutoEndMeeting(participant));
+  });
 
-    it('returns false when single user auto end meeting is not supported', () => {
-      const participant = {
-        doesNotSupportSingleUserAutoEndMeeting: {},
-      };
+  it('returns false when single user auto end meeting is not supported', () => {
+    const participant = {
+      doesNotSupportSingleUserAutoEndMeeting: {},
+    };
 
-      assert.isFalse(MemberUtil.isSupportsSingleUserAutoEndMeeting(participant));
-    });
+    assert.isFalse(MemberUtil.isSupportsSingleUserAutoEndMeeting(participant));
   });
+});
+
 
   describe('MemberUtil.isLiveAnnotationSupported', () => {
     it('throws an error when there is no participant', () => {
@@ -623,7 +585,7 @@ describe('plugin-meetings', () => {
   describe('MemberUtil.isPresenterAssignmentProhibited', () => {
     it('returns true when isPresenterAssignmentProhibited is true', () => {
       const participant = {
-        presenterAssignmentNotAllowed: true,
+        presenterAssignmentNotAllowed: true
       };
 
       assert.isTrue(MemberUtil.isPresenterAssignmentProhibited(participant));
@@ -648,16 +610,16 @@ describe('plugin-meetings', () => {
 describe('extractMediaStatus', () => {
   it('throws an error when there is no participant', () => {
     assert.throws(() => {
-      MemberUtil.extractMediaStatus();
+      MemberUtil.extractMediaStatus()
     }, 'Media status could not be extracted, participant is undefined.');
   });
 
   it('returns undefined media status when participant audio/video status is not present', () => {
     const participant = {
-      status: {},
+      status: {}
     };
 
-    const mediaStatus = MemberUtil.extractMediaStatus(participant);
+    const mediaStatus = MemberUtil.extractMediaStatus(participant)
 
     assert.deepEqual(mediaStatus, {audio: undefined, video: undefined});
   });
@@ -666,11 +628,11 @@ describe('extractMediaStatus', () => {
     const participant = {
       status: {
         audioStatus: 'RECVONLY',
-        videoStatus: 'SENDRECV',
-      },
+        videoStatus: 'SENDRECV'
+      }
     };
 
-    const mediaStatus = MemberUtil.extractMediaStatus(participant);
+    const mediaStatus = MemberUtil.extractMediaStatus(participant)
 
     assert.deepEqual(mediaStatus, {audio: 'RECVONLY', video: 'SENDRECV'});
   });

package/test/unit/spec/multistream/mediaRequestManager.ts

@@ -666,8 +666,8 @@ describe('MediaRequestManager', () => {
     ]);
   });
 
-  it('clears all the requests on reset()', () => {
-    // send some requests and commit them
+  it('avoids sending duplicate requests and clears all the requests on reset()', () => {
+    // send some requests and commit them one by one
     addReceiverSelectedRequest(1500, fakeReceiveSlots[0], MAX_FS_1080p, false);
     addReceiverSelectedRequest(1501, fakeReceiveSlots[1], MAX_FS_1080p, false);
     addActiveSpeakerRequest(
@@ -722,12 +722,95 @@ describe('MediaRequestManager', () => {
       },
     ]);
 
+    // check that when calling commit()
+    // all requests are not re-sent again (avoid duplicate requests)
+    mediaRequestManager.commit();
+
+    assert.notCalled(sendMediaRequestsCallback);
+
+    // now reset everything
+    mediaRequestManager.reset();
+
+    // calling commit now should not cause any requests to be sent out
+    mediaRequestManager.commit();
+    checkMediaRequestsSent([]);
+  });
+
+  it('makes sure to call requests correctly after reset was called and another request was added', () => {
+    addReceiverSelectedRequest(1500, fakeReceiveSlots[0], MAX_FS_1080p, false);
+
+    assert.notCalled(sendMediaRequestsCallback);
+
+    mediaRequestManager.commit();
+    checkMediaRequestsSent([
+      {
+        policy: 'receiver-selected',
+        csi: 1500,
+        receiveSlot: fakeWcmeSlots[0],
+        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_1080p,
+        maxFs: MAX_FS_1080p,
+        maxMbps: MAX_MBPS_1080p,
+      },
+    ]);
+
     // now reset everything
     mediaRequestManager.reset();
 
     // calling commit now should not cause any requests to be sent out
     mediaRequestManager.commit();
     checkMediaRequestsSent([]);
+
+    //add new request
+    addReceiverSelectedRequest(1501, fakeReceiveSlots[1], MAX_FS_1080p, false);
+
+    // commit
+    mediaRequestManager.commit();
+
+    // check the new request was sent
+    checkMediaRequestsSent([
+      {
+        policy: 'receiver-selected',
+        csi: 1501,
+        receiveSlot: fakeWcmeSlots[1],
+        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_1080p,
+        maxFs: MAX_FS_1080p,
+        maxMbps: MAX_MBPS_1080p,
+      },
+    ]);
+  });
+
+  it('can send same media request after previous requests have been cleared', () => {
+    // add a request and commit
+    addReceiverSelectedRequest(1500, fakeReceiveSlots[0], MAX_FS_1080p, false);
+    mediaRequestManager.commit();
+    checkMediaRequestsSent([
+      {
+        policy: 'receiver-selected',
+        csi: 1500,
+        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_1080p,
+        receiveSlot: fakeWcmeSlots[0],
+        maxFs: MAX_FS_1080p,
+        maxMbps: MAX_MBPS_1080p,
+      },
+    ]);
+
+    // clear previous requests
+    mediaRequestManager.clearPreviousRequests();
+
+    // commit same request
+    mediaRequestManager.commit();
+
+    // check the request was sent
+    checkMediaRequestsSent([
+      {
+        policy: 'receiver-selected',
+        csi: 1500,
+        maxPayloadBitsPerSecond: MAX_PAYLOADBITSPS_1080p,
+        receiveSlot: fakeWcmeSlots[0],
+        maxFs: MAX_FS_1080p,
+        maxMbps: MAX_MBPS_1080p,
+      },
+    ]);
   });
 
   it('re-sends media requests after degradation preferences are set', () => {

package/test/unit/spec/multistream/remoteMediaManager.ts

@@ -965,36 +965,6 @@ describe('RemoteMediaManager', () => {
       );
     });
 
-    it('allocates 25 video slots for AllEqual25 layout', async () => {
-      const config = cloneDeep(DefaultTestConfiguration);
-      config.video.layouts['AllEqual25'] = {
-        activeSpeakerVideoPaneGroups: [
-          {id: 'main', numPanes: 25, size: 'best', priority: 255},
-        ],
-      };
-      config.video.initialLayoutId = 'AllEqual25';
-
-      let slotCount = 0;
-      fakeReceiveSlotManager.allocateSlot.callsFake((mediaType: MediaType) => {
-        if (mediaType === MediaType.VideoMain) {
-          slotCount += 1;
-          return Promise.resolve(new FakeSlot(mediaType, `fake video ${slotCount}`));
-        }
-        return Promise.resolve(fakeAudioSlot);
-      });
-
-      remoteMediaManager = new RemoteMediaManager(
-        fakeReceiveSlotManager,
-        fakeMediaRequestManagers,
-        config
-      );
-
-      await remoteMediaManager.start();
-
-      assert.strictEqual(remoteMediaManager.getLayoutId(), 'AllEqual25');
-      assert.strictEqual(remoteMediaManager.slots.video.activeSpeaker.length, 25);
-    });
-
     it('releases slots when switching to layout that requires less active speaker slots', async () => {
       // start with "AllEqual" layout that needs just 9 video slots
       const config = cloneDeep(DefaultTestConfiguration);

package/test/unit/spec/multistream/sendSlotManager.ts

@@ -1,28 +1,19 @@
 import 'jsdom-global/register';
 import SendSlotManager from '@webex/plugin-meetings/src/multistream/sendSlotManager';
-import { LocalStream, MediaType, MultistreamRoapMediaConnection, MediaCodecMimeType } from "@webex/internal-media-core";
-import {assert, expect} from '@webex/test-helper-chai';
+import { LocalStream, MediaType, MultistreamRoapMediaConnection } from "@webex/internal-media-core";
+import {expect} from '@webex/test-helper-chai';
 import sinon from 'sinon';
-import Metrics from '@webex/plugin-meetings/src/metrics';
-import BEHAVIORAL_METRICS from '@webex/plugin-meetings/src/metrics/constants';
 
 describe('SendSlotsManager', () => {
     let sendSlotsManager: SendSlotManager;
     const LoggerProxy = {
         logger: {
             info: sinon.stub(),
-            warn: sinon.stub(),
-            error: sinon.stub(),
         },
     };
 
     beforeEach(() => {
         sendSlotsManager = new SendSlotManager(LoggerProxy);
-        sinon.stub(Metrics, 'sendBehavioralMetric');
-    });
-
-    afterEach(() => {
-        sinon.restore();
     });
 
     describe('createSlot', () => {
@@ -38,13 +29,13 @@ describe('SendSlotsManager', () => {
         it('should create a slot for the given mediaType', () => {
             sendSlotsManager.createSlot(mediaConnection, mediaType);
 
-            assert.calledWith(mediaConnection.createSendSlot, mediaType, true);
+            expect(mediaConnection.createSendSlot.calledWith(mediaType, true));
         });
 
         it('should create a slot for the given mediaType & active state', () => {
             sendSlotsManager.createSlot(mediaConnection, mediaType, false);
 
-            assert.calledWith(mediaConnection.createSendSlot, mediaType, false);
+            expect(mediaConnection.createSendSlot.calledWith(mediaType, false));
         });
 
         it('should throw an error if a slot for the given mediaType already exists', () => {
@@ -95,12 +86,14 @@ describe('SendSlotsManager', () => {
 
             await sendSlotsManager.publishStream(mediaType, stream);
 
-            assert.calledWith(slot.publishStream, stream);
+            expect(slot.publishStream.calledWith(stream));
         });
 
-        it('should throw an error if a slot for the given mediaType does not exist', async () => {
-            await expect(sendSlotsManager.publishStream(mediaType, stream))
-                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
+        it('should throw an error if a slot for the given mediaType does not exist', (done) => {
+            sendSlotsManager.publishStream(mediaType, stream).catch((error) => {
+                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
+                done();
+            });
         });
     });
 
@@ -123,12 +116,14 @@ describe('SendSlotsManager', () => {
 
             await sendSlotsManager.unpublishStream(mediaType);
 
-            assert.called(slot.unpublishStream);
+            expect(slot.unpublishStream.called);
         });
 
-        it('should throw an error if a slot for the given mediaType does not exist', async () => {
-            await expect(sendSlotsManager.unpublishStream(mediaType))
-                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
+        it('should throw an error if a slot for the given mediaType does not exist',(done) => {
+            sendSlotsManager.unpublishStream(mediaType).catch((error) => {
+                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
+                done();
+            });
         });
     });
 
@@ -152,7 +147,7 @@ describe('SendSlotsManager', () => {
 
       await sendSlotsManager.setNamedMediaGroups(mediaType, groups);
 
-      assert.calledWith(slot.setNamedMediaGroups, groups);
+      expect(slot.setNamedMediaGroups.calledWith(groups));
     });
 
     it('should throw an error if the given mediaType is not audio', () => {
@@ -174,16 +169,16 @@ describe('SendSlotsManager', () => {
             } as MultistreamRoapMediaConnection;
         });
 
-        it('should set the active state of the sendSlot for the given mediaType', () => {
+        it('should set the active state of the sendSlot for the given mediaType', async () => {
             const slot = {
-                active: false,
+                setActive: sinon.stub().resolves(),
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
 
-            sendSlotsManager.setActive(mediaType, true);
+            await sendSlotsManager.setActive(mediaType,true);
 
-            expect(slot.active).to.be.true;
+            expect(slot.setActive.called);
         });
 
         it('should throw an error if a slot for the given mediaType does not exist', () => {
@@ -202,7 +197,7 @@ describe('SendSlotsManager', () => {
             } as MultistreamRoapMediaConnection;
         });
 
-        it('should delegate to slot.setCodecParameters, log deprecation warning and send deprecation metric', async () => {
+        it('should set the codec parameters of the sendSlot for the given mediaType', async () => {
             const slot = {
                 setCodecParameters: sinon.stub().resolves(),
             };
@@ -211,17 +206,14 @@ describe('SendSlotsManager', () => {
 
             await sendSlotsManager.setCodecParameters(mediaType, codecParameters);
 
-            assert.calledWith(slot.setCodecParameters, codecParameters);
-            assert.called(LoggerProxy.logger.warn);
-            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
-                BEHAVIORAL_METRICS.DEPRECATED_SET_CODEC_PARAMETERS_USED,
-                { mediaType, codecParameters }
-            );
+            expect(slot.setCodecParameters.calledWith(codecParameters));
         });
 
-        it('should throw an error if a slot for the given mediaType does not exist', async () => {
-            await expect(sendSlotsManager.setCodecParameters(mediaType, codecParameters))
-                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
+        it('should throw an error if a slot for the given mediaType does not exist', (done) => {
+            sendSlotsManager.setCodecParameters(mediaType, codecParameters).catch((error) => {
+                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
+                done();
+            });
         });
     });
 
@@ -235,114 +227,23 @@ describe('SendSlotsManager', () => {
             } as MultistreamRoapMediaConnection;
         });
 
-        it('should delegate to slot.deleteCodecParameters, log deprecation warning and send deprecation metric', async () => {
+        it('should delete the codec parameters of the sendSlot for the given mediaType', async () => {
             const slot = {
                 deleteCodecParameters: sinon.stub().resolves(),
             };
             mediaConnection.createSendSlot.returns(slot);
             sendSlotsManager.createSlot(mediaConnection, mediaType);
 
-            await sendSlotsManager.deleteCodecParameters(mediaType, []);
-
-            assert.calledWith(slot.deleteCodecParameters, []);
-            assert.called(LoggerProxy.logger.warn);
-            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
-                BEHAVIORAL_METRICS.DEPRECATED_DELETE_CODEC_PARAMETERS_USED,
-                { mediaType, parameters: [] }
-            );
-        });
-
-        it('should throw an error if a slot for the given mediaType does not exist', async () => {
-            await expect(sendSlotsManager.deleteCodecParameters(mediaType, []))
-                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
-        });
-    });
-
-    describe('setCustomCodecParameters', () => {
-        let mediaConnection;
-        const mediaType = MediaType.AudioMain;
-        const codecMimeType = MediaCodecMimeType.OPUS;
-        const parameters = { maxaveragebitrate: '64000' };
-
-        beforeEach(() => {
-            mediaConnection = {
-                createSendSlot: sinon.stub(),
-            } as MultistreamRoapMediaConnection;
-        });
-
-        it('should set custom codec parameters on the sendSlot for the given mediaType and codec, log info and send metric', async () => {
-            const slot = {
-                setCustomCodecParameters: sinon.stub().resolves(),
-            };
-            mediaConnection.createSendSlot.returns(slot);
-            sendSlotsManager.createSlot(mediaConnection, mediaType);
-
-            await sendSlotsManager.setCustomCodecParameters(mediaType, codecMimeType, parameters);
-
-            assert.calledWith(slot.setCustomCodecParameters, codecMimeType, parameters);
-            assert.called(LoggerProxy.logger.info);
-            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
-                BEHAVIORAL_METRICS.SET_CUSTOM_CODEC_PARAMETERS_USED,
-                { mediaType, codecMimeType, parameters }
-            );
-        });
-
-        it('should throw an error if a slot for the given mediaType does not exist', async () => {
-            await expect(sendSlotsManager.setCustomCodecParameters(mediaType, codecMimeType, parameters))
-                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
-        });
-
-        it('should throw and log error when setCustomCodecParameters fails', async () => {
-            const error = new Error('codec parameter failure');
-            const slot = {
-                setCustomCodecParameters: sinon.stub().rejects(error),
-            };
-            mediaConnection.createSendSlot.returns(slot);
-            sendSlotsManager.createSlot(mediaConnection, mediaType);
-
-            await expect(sendSlotsManager.setCustomCodecParameters(mediaType, codecMimeType, parameters))
-                .to.be.rejectedWith('codec parameter failure');
-
-            assert.called(LoggerProxy.logger.error);
-            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
-                BEHAVIORAL_METRICS.SET_CUSTOM_CODEC_PARAMETERS_USED,
-                { mediaType, codecMimeType, parameters }
-            );
-        });
-    });
-
-    describe('markCustomCodecParametersForDeletion', () => {
-        let mediaConnection;
-        const mediaType = MediaType.AudioMain;
-        const codecMimeType = MediaCodecMimeType.OPUS;
-        const parameters = ['maxaveragebitrate', 'maxplaybackrate'];
-
-        beforeEach(() => {
-            mediaConnection = {
-                createSendSlot: sinon.stub(),
-            } as MultistreamRoapMediaConnection;
-        });
-
-        it('should mark custom codec parameters for deletion on the sendSlot for the given mediaType and codec, log info and send metric', async () => {
-            const slot = {
-                markCustomCodecParametersForDeletion: sinon.stub().resolves(),
-            };
-            mediaConnection.createSendSlot.returns(slot);
-            sendSlotsManager.createSlot(mediaConnection, mediaType);
-
-            await sendSlotsManager.markCustomCodecParametersForDeletion(mediaType, codecMimeType, parameters);
+            await sendSlotsManager.deleteCodecParameters(mediaType,[]);
 
-            assert.calledWith(slot.markCustomCodecParametersForDeletion, codecMimeType, parameters);
-            assert.called(LoggerProxy.logger.info);
-            assert.calledWith(Metrics.sendBehavioralMetric as sinon.SinonStub,
-                BEHAVIORAL_METRICS.MARK_CUSTOM_CODEC_PARAMETERS_FOR_DELETION_USED,
-                { mediaType, codecMimeType, parameters }
-            );
+            expect(slot.deleteCodecParameters.called);
         });
 
-        it('should throw an error if a slot for the given mediaType does not exist', async () => {
-            await expect(sendSlotsManager.markCustomCodecParametersForDeletion(mediaType, codecMimeType, parameters))
-                .to.be.rejectedWith(`Slot for ${mediaType} does not exist`);
+        it('should throw an error if a slot for the given mediaType does not exist', (done) => {
+            sendSlotsManager.deleteCodecParameters(mediaType,[]).catch((error) => {
+                expect(error.message).to.equal(`Slot for ${mediaType} does not exist`);
+                done();
+            });
         });
     });