@webex/plugin-meetings 3.10.0-next.3 → 3.10.0-next.30

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

@@ -0,0 +1,140 @@
+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/locusRouteToken.ts

@@ -54,6 +54,23 @@ describe('LocusRouteTokenInterceptor', () => {
     assert.equal(interceptor.getToken(TEST_LOCUS_ID), 'test-token');
   });
 
+  it('get route token case insensitively ', async () => {
+    const response = {
+      headers: {
+        ['x-cisco-part-route-token']: 'test-token',
+      },
+    };
+
+    const result = await interceptor.onResponse(
+      {
+        uri: `https://locus-test.webex.com/locus/api/v1/loci/${TEST_LOCUS_ID}/foo`,
+      },
+      response
+    );
+    assert.equal(result, response);
+    assert.equal(interceptor.getToken(TEST_LOCUS_ID), 'test-token');
+  });
+
   it('onResponse should not store token when header missing', async () => {
     interceptor.updateToken(TEST_LOCUS_ID);
     const response = {headers: {}};
@@ -84,4 +101,14 @@ describe('LocusRouteTokenInterceptor', () => {
     interceptor.updateToken(TEST_LOCUS_ID, 'abc456');
     assert.equal(interceptor.getToken(TEST_LOCUS_ID), 'abc456');
   });
+
+  it('should delete token when updateToken called with "null"', () => {
+    interceptor.updateToken(TEST_LOCUS_ID, 'null');
+    assert.isUndefined(interceptor.getToken(TEST_LOCUS_ID));
+  });
+
+  it('should delete token when updateToken called with null', () => {
+    interceptor.updateToken(TEST_LOCUS_ID, null);
+    assert.isUndefined(interceptor.getToken(TEST_LOCUS_ID));
+  });
 });