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

package/test/unit/spec/hashTree/utils.ts

@@ -1,140 +0,0 @@
-import {HashTreeObject, ObjectType} from '../../../../src/hashTree/types';
-import {deleteNestedObjectsWithHtMeta, isSelf} from '../../../../src/hashTree/utils';
-
-import {assert} from '@webex/test-helper-chai';
-
-describe('Hash Tree Utils', () => {
-  describe('#deleteNestedObjectsWithHtMeta', () => {
-    it('should delete nested objects with htMeta', () => {
-      const locusPart = {
-        a: {
-          htMeta: {
-            id: '1',
-          },
-          value: 'to be deleted',
-        },
-        b: {
-          c: {
-            htMeta: {
-              id: '2',
-            },
-            value: 'to be deleted',
-          },
-          d: 'to be kept',
-        },
-        e: [
-          {
-            htMeta: {
-              id: '3',
-            },
-            value: 'to be deleted',
-          },
-          {
-            f: 'to be kept',
-          },
-          {
-            htMeta: {
-              id: '4',
-            },
-            value: 'to be deleted',
-          },
-          {
-            g: 'to be kept',
-          },
-        ],
-      };
-
-      deleteNestedObjectsWithHtMeta(locusPart);
-
-      assert.deepEqual(locusPart, {
-        b: {
-          d: 'to be kept',
-        },
-        e: [
-          {
-            f: 'to be kept',
-          },
-          {
-            g: 'to be kept',
-          },
-        ],
-      });
-    });
-
-    it('should handle arrays correctly', () => {
-      const locusPart = {
-        htMeta: {
-          id: '0', // this should not be deleted
-        },
-        participants: [
-          {
-            htMeta: {
-              id: '1',
-            },
-            id: 'participant1',
-            value: 'to be deleted',
-          },
-          {
-            htMeta: {
-              id: '2',
-            },
-            id: 'participant2',
-            value: 'to be deleted',
-          },
-        ],
-        self: {
-          htMeta: {
-            id: '3',
-          },
-          id: 'self1',
-          value: 'to be deleted',
-        },
-      };
-
-      deleteNestedObjectsWithHtMeta(locusPart);
-
-      assert.deepEqual(locusPart, {
-        htMeta: {
-          id: '0',
-        },
-        participants: [],
-      });
-    });
-  });
-
-  describe('#isSelf', () => {
-    ['self', 'SELF', 'Self'].forEach((type) => {
-      it(`should return true for object with type="${type}"`, () => {
-        const selfObject = {
-          htMeta: {
-            elementId: {
-              type,
-              id: 1,
-              version: 1,
-            },
-            dataSetNames: [],
-          },
-          data: {},
-        };
-
-        assert.isTrue(isSelf(selfObject as HashTreeObject));
-      });
-    });
-
-    it('should return false for non-self object', () => {
-      const participantObject = {
-        htMeta: {
-          elementId: {
-            type: ObjectType.participant,
-            id: 2,
-            version: 1,
-          },
-          dataSetNames: [],
-        },
-        data: {},
-      };
-
-      assert.isFalse(isSelf(participantObject));
-    });
-  });
-});

package/test/unit/spec/interceptors/dataChannelAuthToken.ts

@@ -1,210 +0,0 @@
-import 'jsdom-global/register';
-import {assert, expect} from '@webex/test-helper-chai';
-import sinon from 'sinon';
-import MockWebex from '@webex/test-helper-mock-webex';
-import {WebexHttpError} from '@webex/webex-core';
-import DataChannelAuthTokenInterceptor from '@webex/plugin-meetings/src/interceptors/dataChannelAuthToken';
-import LoggerProxy from '@webex/plugin-meetings/src/common/logs/logger-proxy';
-import * as utils from '@webex/plugin-meetings/src/interceptors/utils';
-import {DATA_CHANNEL_AUTH_HEADER, MAX_RETRY} from '@webex/plugin-meetings/src/interceptors/constant';
-
-describe('plugin-meetings', () => {
-  describe('Interceptors', () => {
-    describe('DataChannelAuthTokenInterceptor', () => {
-      let interceptor, webex, clock;
-
-      beforeEach(() => {
-        clock = sinon.useFakeTimers();
-        sinon.stub(LoggerProxy, 'logger').value({
-          error: sinon.stub(),
-          warn: sinon.stub(),
-        });
-
-        webex = new MockWebex({children: {}});
-        webex.request = sinon.stub().resolves({});
-
-        interceptor = Reflect.apply(DataChannelAuthTokenInterceptor.create, webex, []);
-
-        interceptor._refreshDataChannelToken = sinon.stub();
-        interceptor._isDataChannelTokenEnabled = sinon.stub().resolves(true);
-      });
-
-      afterEach(() => {
-        sinon.restore();
-        clock.restore();
-      });
-
-      const makeReason = (statusCode) =>
-        new WebexHttpError({
-          statusCode,
-          options: {headers: {}, uri: 'https://example.com'},
-          body: {},
-        });
-
-      describe('#onResponseError', () => {
-        it('rejects when no Data-Channel-Auth-Token header exists', async () => {
-          const options = {headers: {}};
-          const reason = makeReason(401);
-
-          await assert.isRejected(interceptor.onResponseError(options, reason), reason);
-        });
-
-        it('rejects when statusCode is not 401/403', async () => {
-          const options = {headers: {[DATA_CHANNEL_AUTH_HEADER]: 'abc'}};
-          const reason = makeReason(500);
-
-          await assert.isRejected(interceptor.onResponseError(options, reason), reason);
-        });
-
-        it('rejects when retry count exceeds MAX_RETRY', async () => {
-          const options = {headers: {[DATA_CHANNEL_AUTH_HEADER]: 'abc'}};
-          const reason = makeReason(401);
-
-          for (let i = 0; i < MAX_RETRY; i++) {
-            interceptor.onResponseError(options, reason).catch(() => {});
-          }
-
-          await assert.isRejected(interceptor.onResponseError(options, reason), reason);
-
-          sinon.assert.calledOnce(LoggerProxy.logger.error);
-        });
-
-        it('calls refreshTokenAndRetryWithDelay when eligible', async () => {
-          const options = {headers: {[DATA_CHANNEL_AUTH_HEADER]: 'abc'}};
-          const reason = makeReason(401);
-
-          interceptor._isDataChannelTokenEnabled.resolves(true);
-
-          const stub = sinon.stub(interceptor, 'refreshTokenAndRetryWithDelay').resolves('ok');
-
-          await interceptor.onResponseError(options, reason);
-
-          sinon.assert.calledOnceWithExactly(stub, options);
-        });
-
-        it('rejects when isDataChannelTokenEnabled is false', async () => {
-          const options = {headers: {[DATA_CHANNEL_AUTH_HEADER]: 'abc'}};
-          const reason = makeReason(401);
-
-          interceptor._isDataChannelTokenEnabled.resolves(false);
-
-          await assert.isRejected(interceptor.onResponseError(options, reason), reason);
-        });
-      });
-
-      describe('#onRequest', () => {
-        let isJwtTokenExpiredStub;
-
-        beforeEach(() => {
-          isJwtTokenExpiredStub = sinon.stub(utils, 'isJwtTokenExpired').returns(false);
-        });
-
-        it('does nothing when token is missing', async () => {
-          const options = {headers: {}};
-
-          const res = await interceptor.onRequest(options);
-
-          expect(res).to.equal(options);
-          sinon.assert.notCalled(isJwtTokenExpiredStub);
-        });
-
-        it('does nothing when feature is disabled', async () => {
-          interceptor._isDataChannelTokenEnabled.resolves(false);
-
-          const options = {headers: {[DATA_CHANNEL_AUTH_HEADER]: 'old-token'}};
-          const res = await interceptor.onRequest(options);
-
-          expect(res).to.equal(options);
-          sinon.assert.notCalled(isJwtTokenExpiredStub);
-        });
-
-        it('does not refresh when token is not expired', async () => {
-          interceptor._isDataChannelTokenEnabled.resolves(true);
-          isJwtTokenExpiredStub.returns(false);
-
-          const options = {headers: {[DATA_CHANNEL_AUTH_HEADER]: 'old-token'}};
-          const res = await interceptor.onRequest(options);
-
-          sinon.assert.notCalled(interceptor._refreshDataChannelToken);
-          expect(res.headers[DATA_CHANNEL_AUTH_HEADER]).to.equal('old-token');
-        });
-
-        it('refreshes token when expired', async () => {
-          interceptor._isDataChannelTokenEnabled.resolves(true);
-          isJwtTokenExpiredStub.returns(true);
-
-          interceptor._refreshDataChannelToken.resolves('new-token');
-
-          const options = {headers: {[DATA_CHANNEL_AUTH_HEADER]: 'old-token'}};
-          const res = await interceptor.onRequest(options);
-
-          sinon.assert.calledOnce(interceptor._refreshDataChannelToken);
-          expect(res.headers[DATA_CHANNEL_AUTH_HEADER]).to.equal('new-token');
-        });
-
-        it('continues request when refresh fails', async () => {
-          interceptor._isDataChannelTokenEnabled.resolves(true);
-          isJwtTokenExpiredStub.returns(true);
-
-          interceptor._refreshDataChannelToken.rejects(new Error('refresh failed'));
-
-          const options = {headers: {[DATA_CHANNEL_AUTH_HEADER]: 'old-token'}};
-          const res = await interceptor.onRequest(options);
-
-          expect(res.headers[DATA_CHANNEL_AUTH_HEADER]).to.equal('old-token');
-        });
-      });
-
-      describe('#refreshTokenAndRetryWithDelay', () => {
-        const options = {
-          headers: {[DATA_CHANNEL_AUTH_HEADER]: 'old-token'},
-          method: 'GET',
-          uri: 'https://example.com',
-        };
-
-        it('refreshes token and retries request successfully', async () => {
-          interceptor._refreshDataChannelToken.resolves('new-token');
-          webex.request.resolves('mock-response');
-
-          const promise = interceptor.refreshTokenAndRetryWithDelay(options);
-
-          clock.tick(2000);
-
-          const result = await promise;
-
-          expect(interceptor._refreshDataChannelToken.calledOnce).to.be.true;
-          expect(options.headers[DATA_CHANNEL_AUTH_HEADER]).to.equal('new-token');
-          expect(webex.request.calledOnceWith(options)).to.be.true;
-          expect(result).to.equal('mock-response');
-        });
-
-        it('rejects when refreshDataChannelToken fails', async () => {
-          interceptor._refreshDataChannelToken.rejects(new Error('refresh failed'));
-
-          const promise = interceptor.refreshTokenAndRetryWithDelay(options);
-
-          clock.tick(2000);
-
-          await assert.isRejected(
-            promise,
-            /DataChannel token refresh failed: refresh failed/
-          );
-        });
-
-        it('rejects when retry request fails', async () => {
-          interceptor._refreshDataChannelToken.resolves('new-token');
-          webex.request.rejects(new Error('request failed'));
-
-          const promise = interceptor.refreshTokenAndRetryWithDelay(options);
-
-          clock.tick(2000);
-
-          await assert.isRejected(
-            promise,
-            /DataChannel token refresh failed: request failed/
-          );
-        });
-      });
-    });
-  });
-});

package/test/unit/spec/interceptors/utils.ts

@@ -1,75 +0,0 @@
-import 'jsdom-global/register';
-import {expect} from '@webex/test-helper-chai';
-import sinon from 'sinon';
-import {isJwtTokenExpired} from '@webex/plugin-meetings/src/interceptors/utils';
-
-const makeJwt = (payload) =>
-  [
-    Buffer.from(JSON.stringify({alg: 'none', typ: 'JWT'})).toString('base64url'),
-    Buffer.from(JSON.stringify(payload)).toString('base64url'),
-    ''
-  ].join('.');
-
-describe('plugin-meetings', () => {
-  describe('Interceptors', () => {
-    describe('utils - isJwtTokenExpired', () => {
-      let clock;
-
-      beforeEach(() => {
-        clock = sinon.useFakeTimers();
-      });
-
-      afterEach(() => {
-        sinon.restore();
-        clock.restore();
-      });
-
-      it('returns false when token has no exp', () => {
-        const token = makeJwt({}); // no exp
-
-        const result = isJwtTokenExpired(token);
-
-        expect(result).to.equal(false);
-      });
-
-      it('returns false when token is not expired', () => {
-        const now = Date.now();
-        const futureExp = Math.floor((now + 60 * 1000) / 1000);
-
-        const token = makeJwt({exp: futureExp});
-
-        const result = isJwtTokenExpired(token);
-
-        expect(result).to.equal(false);
-      });
-
-      it('returns true when token is expired', () => {
-        const now = Date.now();
-        const pastExp = Math.floor((now - 60 * 1000) / 1000);
-
-        const token = makeJwt({exp: pastExp});
-
-        const result = isJwtTokenExpired(token);
-
-        expect(result).to.equal(true);
-      });
-
-      it('returns true when token expires within EXPIRY_BUFFER', () => {
-        const now = Date.now();
-        const expSoon = Math.floor((now + 10 * 1000) / 1000);
-
-        const token = makeJwt({exp: expSoon});
-
-        const result = isJwtTokenExpired(token);
-
-        expect(result).to.equal(true);
-      });
-
-      it('returns true when token is invalid', () => {
-        const result = isJwtTokenExpired('not-a-jwt');
-
-        expect(result).to.equal(true);
-      });
-    });
-  });
-});

package/test/unit/spec/webinar/utils.ts

@@ -1,39 +0,0 @@
-import chai from 'chai';
-import {sanitizeParams} from '@webex/plugin-meetings/src/webinar/utils';
-
-const {assert} = chai;
-
-describe('plugin-meetings', () => {
-  describe('webinar utils', () => {
-    describe('#sanitizeParams', () => {
-      it('sanitizes params by removing undefined, "", or null values', () => {
-        const input = {
-          a: 1,
-          b: undefined,
-          c: null,
-          d: 'test',
-          e: false,
-          f: '',
-        };
-        const expectedOutput = {
-          a: 1,
-          d: 'test',
-          e: false,
-        };
-        const result = sanitizeParams(input);
-        assert.deepEqual(result, expectedOutput);
-      });
-
-      it('returns an empty object when all values are invalid', () => {
-        const input = {
-          a: undefined,
-          b: null,
-          c: '',
-        };
-        const expectedOutput = {};
-        const result = sanitizeParams(input);
-        assert.deepEqual(result, expectedOutput);
-      });
-    });
-  });
-});