@webex/plugin-meetings 3.9.0-webinar5k.1 → 3.9.0

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

@@ -1,394 +0,0 @@
-import HashTree from '@webex/plugin-meetings/src/hashTree/hashTree';
-import {EMPTY_HASH} from '@webex/plugin-meetings/src/hashTree/constants';
-
-import { expect } from "@webex/test-helper-chai";
-
-// Define a type for the leaf data items used in tests
-type LeafDataItem = {
-  type: string;
-  id: number;
-  version: number;
-};
-
-describe('HashTree', () => {
-  it('should initialize with empty leaves and hashes', () => {
-    const leafData: LeafDataItem[] = [];
-    const numLeaves = 4;
-    const hashTree = new HashTree(leafData, numLeaves);
-
-    expect(hashTree.leaves).to.deep.equal(new Array(numLeaves).fill(null).map(() => ({})));
-    expect(hashTree.leafHashes).to.deep.equal(new Array(numLeaves).fill(EMPTY_HASH));
-    expect(hashTree.getLeafCount()).to.equal(numLeaves);
-    expect(hashTree.getTotalItemCount()).to.equal(0);
-  });
-
-  it('constructor should allow 0 leaves', () => {
-    const leafData: LeafDataItem[] = [];
-    const numLeaves = 0;
-    const hashTree = new HashTree(leafData, numLeaves);
-    expect(hashTree.getLeafCount()).to.equal(0);
-    expect(hashTree.getRootHash()).to.equal(EMPTY_HASH);
-    expect(hashTree.getHashes()).to.deep.equal([EMPTY_HASH]);
-  });
-
-  it('number of leaves must be 0 or a power of 2', () => {
-    const leafData: LeafDataItem[] = [];
-    const numLeaves = 3; // Not a power of 2
-    expect(() => new HashTree(leafData, numLeaves)).to.throw('Number of leaves must be a power of 2, saw 3');
-    const numLeavesNegative = -1;
-    expect(() => new HashTree(leafData, numLeavesNegative)).to.throw('Number of leaves must be a power of 2, saw -1');
-  });
-
-  it('should have the correct hashes after putting ObjectIds using constructor', () => {
-    const oids: LeafDataItem[] = [
-      {type: 'participant', id: 1, version: 3} // Hashes to bucket 1 % 4 = 1
-    ];
-    // numLeaves is 4. Item id 1 % 4 = 1. So, leafHashes[1] will be updated.
-    // leafHashes[0], leafHashes[2], leafHashes[3] remain EMPTY_HASH.
-    const tree = new HashTree(oids, 4);
-
-    // These are the expected hash values from the Java reference for a similar structure.
-    // The actual values depend on the specific XXHash128 implementation and input serialization.
-    // For this test, we'll use the previously provided values, assuming they are correct for the TS implementation.
-    expect(tree.getHashes()).to.deep.equal([
-        "24a75d115a0a90ddb376a02b435c780f", // Root hash
-        "457eeb22808eadfcff92ee47d67acbbf", // Internal node (children: leaf 0, leaf 1)
-        "b113a76304e3a7121afecfe1606ee1c1", // Internal node (children: leaf 2, leaf 3)
-        EMPTY_HASH,                         // Leaf 0 hash (empty)
-        "42df811f5a902c5b6bfcf50c7004e275", // Leaf 1 hash (for item {type: 'participant', id: 1, version: 3})
-        EMPTY_HASH,                         // Leaf 2 hash (empty)
-        EMPTY_HASH                          // Leaf 3 hash (empty)
-    ]);
-    expect(tree.getRootHash()).to.equal("24a75d115a0a90ddb376a02b435c780f");
-  });
-
-  it('should have the correct hashes after putting multiple ObjectIds using constructor', () => {
-    const oids: LeafDataItem[] = [
-      {type: "typeA", id: 1, version: 3}, // Leaf 1 (1 % 4 = 1)
-      {type: "typeA", id: 6, version: 2}, // Leaf 2 (6 % 4 = 2)
-      {type: "typeA", id: 7, version: 1}, // Leaf 3 (7 % 4 = 3)
-      {type: "typeB", id: 11, version: 4},// Leaf 3 (11 % 4 = 3)
-    ];
-    const tree = new HashTree(oids, 4);
-
-      // Corrected expected hashes based on the test failure output
-      expect(tree.getHashes()).to.deep.equal([
-          "c8415198d4abca6f885fe974e9b3729d", // Root
-          "457eeb22808eadfcff92ee47d67acbbf", // Internal node (L0, L1)
-          "5c9ba182a069c16a77a1928fce52dad8", // Internal node (L2, L3)
-          EMPTY_HASH,                         // Leaf 0 (empty)
-          "42df811f5a902c5b6bfcf50c7004e275", // Leaf 1 (item id 1)
-          "feb384d8ac6374ffdbee92a9f48f2b40", // Leaf 2 (item id 6)
-          "ebfa4f7e104e1e30fbb6b8857ccb685d"  // Leaf 3 (items id 7, 11)
-      ]);
-      expect(tree.getRootHash()).to.equal("c8415198d4abca6f885fe974e9b3729d");
-  });
-
-  it('should putItems and compute hashes correctly', () => {
-    const initialLeafData: LeafDataItem[] = [];
-    const numLeaves = 4;
-    const hashTree = new HashTree(initialLeafData, numLeaves);
-
-    const itemsToPut: LeafDataItem[] = [
-      { type: 'participant', id: 1, version: 1 }, // bucket 1
-      { type: 'participant', id: 2, version: 1 }, // bucket 2
-    ];
-    const results = hashTree.putItems(itemsToPut);
-
-    expect(results).to.deep.equal([true, true]);
-    expect(hashTree.leaves[1]['participant'][1]).to.deep.equal({ type: 'participant', id: 1, version: 1 });
-    expect(hashTree.leaves[2]['participant'][2]).to.deep.equal({ type: 'participant', id: 2, version: 1 });
-    expect(hashTree.leafHashes[0]).to.equal(EMPTY_HASH);
-    expect(hashTree.leafHashes[1]).to.not.equal(EMPTY_HASH);
-    expect(hashTree.leafHashes[2]).to.not.equal(EMPTY_HASH);
-    expect(hashTree.leafHashes[3]).to.equal(EMPTY_HASH);
-    expect(hashTree.getTotalItemCount()).to.equal(2);
-  });
-
-  it('putItem should add a single item and update hash', () => {
-    const hashTree = new HashTree([], 2);
-    const item: LeafDataItem = {type: 'data', id: 3, version: 1}; // bucket 1
-    
-    const result = hashTree.putItem(item);
-    expect(result).to.be.true;
-    expect(hashTree.leaves[1]['data'][3]).to.deep.equal(item);
-    expect(hashTree.leafHashes[1]).to.not.equal(EMPTY_HASH);
-    expect(hashTree.getTotalItemCount()).to.equal(1);
-
-    const itemSameVersion = {type: 'data', id: 3, version: 1};
-    const resultSame = hashTree.putItem(itemSameVersion);
-    expect(resultSame).to.be.false; // Not updated as version is not newer
-
-    const itemNewerVersion = {type: 'data', id: 3, version: 2};
-    const resultNewer = hashTree.putItem(itemNewerVersion);
-    expect(resultNewer).to.be.true;
-    expect(hashTree.leaves[1]['data'][3].version).to.equal(2);
-  });
-  
-  it('putItem should return false for tree with 0 leaves', () => {
-    const hashTree = new HashTree([], 0);
-    const item: LeafDataItem = {type: 'data', id: 1, version: 1};
-    expect(hashTree.putItem(item)).to.be.false;
-  });
-
-  it('putItems should return array of false for tree with 0 leaves if items are provided', () => {
-    const hashTree = new HashTree([], 0);
-    const items: LeafDataItem[] = [{type: 'data', id: 1, version: 1}];
-    expect(hashTree.putItems(items)).to.deep.equal([false]);
-  });
-
-
-  it('should have correct root hash after putting one item', () => {
-    const leafData: LeafDataItem[] = [{type: 'participant', id: 1, version: 10}]; // bucket 1 (1 % 2 = 1)
-    const numLeaves = 2;
-    const hashTree = new HashTree(leafData, numLeaves);
-
-    expect(hashTree.leaves[1]['participant'][1]).to.deep.equal({
-      type: 'participant',
-      id: 1,
-      version: 10,
-    });
-    // This hash is from the original test.
-    expect(hashTree.getRootHash()).to.equal('e1cb70c75b488d87cbc8f74934a4290b');
-  });
-
-  it('removeItem should remove an item and update hash', () => {
-    const items: LeafDataItem[] = [{type: 'p', id: 1, version: 1}];
-    const hashTree = new HashTree(items, 2); // item in bucket 1
-    expect(hashTree.getTotalItemCount()).to.equal(1);
-    const oldRootHash = hashTree.getRootHash();
-
-    const result = hashTree.removeItem({type: 'p', id: 1, version: 1});
-    expect(result).to.be.true;
-    expect(hashTree.getTotalItemCount()).to.equal(0);
-    expect(hashTree.leaves[1]['p']).to.be.undefined;
-    expect(hashTree.leafHashes[1]).to.equal(EMPTY_HASH);
-    expect(hashTree.getRootHash()).to.not.equal(oldRootHash);
-    // After removing the only item, it should be like an empty tree with 2 leaves
-    const emptyTree = new HashTree([], 2);
-    expect(hashTree.getRootHash()).to.equal(emptyTree.getRootHash());
-
-    const resultNotFound = hashTree.removeItem({type: 'p', id: 1, version: 1});
-    expect(resultNotFound).to.be.false;
-  });
-
-  it('removeItem should only remove if version is <= existing (as per new logic)', () => {
-    const itemV1 = {type: 'test', id: 5, version: 1}; // bucket 1 (5%2=1)
-    const hashTree = new HashTree([itemV1], 2);
-
-    // Try to remove with older version - should fail if strict "version must be >=" is used for removal item
-    // The current removeItem logic: existingItem.version <= item.version for removal
-    let removed = hashTree.removeItem({type: 'test', id: 5, version: 0});
-    expect(removed).to.be.false; 
-
-    removed = hashTree.removeItem({type: 'test', id: 5, version: 1}); // same version
-    expect(removed).to.be.true;
-    expect(hashTree.getTotalItemCount()).to.equal(0);
-
-    hashTree.putItem(itemV1); // re-add
-    expect(hashTree.getTotalItemCount()).to.equal(1);
-    removed = hashTree.removeItem({type: 'test', id: 5, version: 2}); // newer version in request
-    expect(removed).to.be.true;
-    expect(hashTree.getTotalItemCount()).to.equal(0);
-  });
-  
-  it('removeItem should return false for tree with 0 leaves', () => {
-    const hashTree = new HashTree([], 0);
-    const item: LeafDataItem = {type: 'data', id: 1, version: 1};
-    expect(hashTree.removeItem(item)).to.be.false;
-  });
-
-  it('removeItems should process multiple items', () => {
-    const items: LeafDataItem[] = [
-      {type: 'a', id: 1, version: 2}, // bucket 1
-      {type: 'b', id: 2, version: 2}  // bucket 0
-    ];
-    const hashTree = new HashTree(items, 2);
-    expect(hashTree.getTotalItemCount()).to.equal(2);
-
-    const itemsToRemove: LeafDataItem[] = [
-      {type: 'a', id: 1, version: 3}, // remove with newer version (original logic)
-      {type: 'b', id: 2, version: 1}, // attempt remove with older version (should fail by original logic)
-      {type: 'c', id: 3, version: 1}  // item not present
-    ];
-    const results = hashTree.removeItems(itemsToRemove);
-    expect(results).to.deep.equal([true, false, false]);
-    expect(hashTree.getTotalItemCount()).to.equal(1); // item 'b' should remain
-    expect(hashTree.leaves[1]['a']).to.be.undefined;
-    expect(hashTree.leaves[0]['b'][2]).to.deep.equal({type: 'b', id: 2, version: 2});
-  });
-  
-  it('removeItems should return array of false for tree with 0 leaves if items are provided', () => {
-    const hashTree = new HashTree([], 0);
-    const items: LeafDataItem[] = [{type: 'data', id: 1, version: 1}];
-    expect(hashTree.removeItems(items)).to.deep.equal([false]);
-  });
-
-  it('returns the correct root hash for an empty tree (0 leaves)', () => {
-    const hashTree = new HashTree([], 0);
-    expect(hashTree.getRootHash()).to.equal(EMPTY_HASH);
-  });
-
-  it('returns the correct root hash for an empty tree with 2 leaves', () => {
-    const hashTree = new HashTree([], 2);
-    // This hash is from the original test.
-    expect(hashTree.getRootHash()).to.equal('b113a76304e3a7121afecfe1606ee1c1');
-  });
-
-  it('returns the correct root hash for an empty tree with 4 leaves', () => {
-    const hashTree = new HashTree([], 4);
-    // This hash is from the original test.
-    expect(hashTree.getRootHash()).to.equal('b5df9b92242752424d87053a14e6222d');
-  });
-
-  describe('getLeafData', () => {
-    it('should return items from a specific leaf', () => {
-      const items: LeafDataItem[] = [
-        {type: 't1', id: 0, version: 1}, // leaf 0
-        {type: 't2', id: 1, version: 1}, // leaf 1
-        {type: 't1', id: 2, version: 1}, // leaf 0
-      ];
-      const tree = new HashTree(items, 2);
-      const leaf0Data = tree.getLeafData(0);
-      expect(leaf0Data).to.have.deep.members([
-        {type: 't1', id: 0, version: 1},
-        {type: 't1', id: 2, version: 1}
-      ]);
-      expect(leaf0Data.length).to.equal(2);
-
-      const leaf1Data = tree.getLeafData(1);
-      expect(leaf1Data).to.have.deep.members([{type: 't2', id: 1, version: 1}]);
-      expect(leaf1Data.length).to.equal(1);
-    });
-
-    it('should return empty array for invalid leaf index or empty leaf', () => {
-      const tree = new HashTree([{type: 't', id: 0, version: 1}], 2); // item in leaf 0
-      expect(tree.getLeafData(1)).to.deep.equal([]); // leaf 1 is empty
-      expect(tree.getLeafData(2)).to.deep.equal([]); // invalid index
-      expect(tree.getLeafData(-1)).to.deep.equal([]); // invalid index
-    });
-    
-    it('should return empty array for tree with 0 leaves', () => {
-      const tree = new HashTree([], 0);
-      expect(tree.getLeafData(0)).to.deep.equal([]);
-    });
-  });
-
-  describe('resize', () => {
-    it('should resize the tree and redistribute items', () => {
-      const items: LeafDataItem[] = [
-        {type: 'a', id: 0, version: 1}, // old leaf 0 (0%2=0)
-        {type: 'b', id: 1, version: 1}, // old leaf 1 (1%2=1)
-        {type: 'c', id: 2, version: 1}, // old leaf 0 (2%2=0)
-        {type: 'd', id: 3, version: 1}, // old leaf 1 (3%2=1)
-      ];
-      const tree = new HashTree(items, 2);
-      expect(tree.getLeafCount()).to.equal(2);
-      expect(tree.getTotalItemCount()).to.equal(4);
-      const originalRootHash = tree.getRootHash();
-
-      const resized = tree.resize(4);
-      expect(resized).to.be.true;
-      expect(tree.getLeafCount()).to.equal(4);
-      expect(tree.getTotalItemCount()).to.equal(4); // count should remain same
-      
-      // Check redistribution
-      // id:0 -> 0%4 = 0
-      // id:1 -> 1%4 = 1
-      // id:2 -> 2%4 = 2
-      // id:3 -> 3%4 = 3
-      expect(tree.getLeafData(0)).to.deep.include({type: 'a', id: 0, version: 1});
-      expect(tree.getLeafData(1)).to.deep.include({type: 'b', id: 1, version: 1});
-      expect(tree.getLeafData(2)).to.deep.include({type: 'c', id: 2, version: 1});
-      expect(tree.getLeafData(3)).to.deep.include({type: 'd', id: 3, version: 1});
-      expect(tree.getRootHash()).to.not.equal(originalRootHash); // Hash should change
-    });
-
-    it('should return false if size does not change', () => {
-      const tree = new HashTree([], 4);
-      expect(tree.resize(4)).to.be.false;
-    });
-
-    it('should throw error for invalid new number of leaves', () => {
-      const tree = new HashTree([], 4);
-      expect(() => tree.resize(3)).to.throw('New number of leaves must be 0 or a power of 2');
-    });
-
-    it('should handle resize to 0 leaves', () => {
-      const items: LeafDataItem[] = [{type: 'a', id: 0, version: 1}];
-      const tree = new HashTree(items, 2);
-      expect(tree.getTotalItemCount()).to.equal(1);
-      tree.resize(0);
-      expect(tree.getLeafCount()).to.equal(0);
-      expect(tree.getTotalItemCount()).to.equal(0);
-      expect(tree.getRootHash()).to.equal(EMPTY_HASH);
-      expect(tree.leaves.length).to.equal(0);
-      expect(tree.leafHashes.length).to.equal(0);
-    });
-    
-    it('should handle resize from 0 leaves', () => {
-      const tree = new HashTree([], 0);
-      tree.resize(2);
-      expect(tree.getLeafCount()).to.equal(2);
-      expect(tree.getTotalItemCount()).to.equal(0);
-      const emptyTree = new HashTree([], 2);
-      expect(tree.getRootHash()).to.equal(emptyTree.getRootHash());
-    });
-  });
-
-  describe('diffHashes', () => {
-    it('should return empty array if hashes are identical', () => {
-      const items: LeafDataItem[] = [{type: 'x', id: 1, version: 1}];
-      const tree1 = new HashTree(items, 2);
-      const tree2 = new HashTree(items, 2);
-      expect(tree1.diffHashes(tree2.getHashes())).to.deep.equal([]);
-    });
-
-    it('should return differing leaf indices', () => {
-      const tree1 = new HashTree([{type: 'x', id: 0, version: 1}], 4); // item in leaf 0
-      const tree2 = new HashTree([{type: 'y', id: 1, version: 1}], 4); // item in leaf 1
-      // tree1: leaf 0 has item, leaves 1,2,3 empty
-      // tree2: leaf 1 has item, leaves 0,2,3 empty
-      // Expected diffs: leaf 0 (present in 1, not in 2), leaf 1 (present in 2, not in 1)
-      const diff = tree1.diffHashes(tree2.getHashes());
-      expect(diff).to.include.members([0, 1]);
-      // If one leaf's hash is EMPTY_HASH and the other's is a computed hash, they are different.
-    });
-    
-    it('should return all leaf indices if externalHashes is for a different structure (e.g. too short)', () => {
-      const tree = new HashTree([{type: 'x', id: 0, version: 1}], 4);
-      const externalHashesShort = [EMPTY_HASH, EMPTY_HASH]; // Too short for 4 leaves + internal nodes
-      expect(tree.diffHashes(externalHashesShort)).to.deep.equal([0,1,2,3]);
-    });
-
-    it('should handle diff for 0-leaf trees', () => {
-      const tree0 = new HashTree([], 0);
-      expect(tree0.diffHashes([EMPTY_HASH])).to.deep.equal([]);
-      expect(tree0.diffHashes(["some_other_hash"])).to.deep.equal([]); // No leaves to differ
-      const tree2 = new HashTree([],2);
-      // Comparing a 0-leaf tree with a 2-leaf tree's hashes
-      expect(tree0.diffHashes(tree2.getHashes())).to.deep.equal([]);
-    });
-    
-    it('should correctly identify differences when one leaf changes', () => {
-      const initialItems: LeafDataItem[] = [
-        { type: 'a', id: 0, version: 1 }, // leaf 0
-        { type: 'b', id: 1, version: 1 }  // leaf 1
-      ];
-      const tree1 = new HashTree(initialItems, 2);
-      const tree1Hashes = tree1.getHashes();
-
-      const modifiedItems: LeafDataItem[] = [
-        { type: 'a', id: 0, version: 1 }, // leaf 0 (same)
-        { type: 'b', id: 1, version: 2 }  // leaf 1 (changed version)
-      ];
-      const tree2 = new HashTree(modifiedItems, 2);
-      
-      const diff1_2 = tree1.diffHashes(tree2.getHashes());
-      expect(diff1_2).to.deep.equal([1]); // Leaf 1 should differ
-
-      const diff2_1 = tree2.diffHashes(tree1Hashes);
-      expect(diff2_1).to.deep.equal([1]);
-    });
-  });
-});

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

@@ -1,156 +0,0 @@
-import HashTreeParser from '@webex/plugin-meetings/src/hashTree/hashTreeParser';
-import HashTree from '@webex/plugin-meetings/src/hashTree/hashTree';
-import { expect } from "@webex/test-helper-chai";
-
-const exampleInitialLocus = {
-  dataSets: [
-    {
-      url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/main',
-      root: '9bb9d5a911a74d53a915b4dfbec7329f',
-      version: 51118,
-      leafCount: 16,
-      name: 'main',
-      idleMs: 1000,
-      backoff: {maxMs: 1000, exponent: 2}
-    },
-    {
-      url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self',
-      root: '5b8cc7ffda1346d2bfb1c0b60b8ab601',
-      version: 89891,
-      leafCount: 1,
-      name: 'self',
-      idleMs: 1000,
-      backoff: {maxMs: 1000, exponent: 2}
-    },
-    {
-      url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/atd-unmuted',
-      root: '9279d2e149da43a1b8e2cd7cbf77f9f0',
-      version: 91277,
-      leafCount: 16,
-      name: 'atd-unmuted',
-      idleMs: 1000,
-      backoff: {maxMs: 1000, exponent: 2}
-    },
-  ],
-  locus: {
-    url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f',
-    htMeta: {
-      elementId: {
-        type: 'LOCUS',
-        id: 0,
-        version: 5678,
-      },
-      dataSetNames: ['main'],
-    },
-    participants: [
-      {
-        url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/11941033',
-        person: {},
-        htMeta: {
-          elementId: {
-            type: 'PARTICIPANT',
-            id: 14,
-            version: 5678,
-          },
-          dataSetNames: ['atd-active', 'attendees', 'atd-unmuted'],
-        },
-      },
-    ],
-    self: {
-      url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/11941033',
-      visibleDataSets: ['main', 'self', 'atd-unmuted'],
-      person: {},
-      htMeta: {
-        elementId: {
-          type: 'SELF',
-          id: 4,
-          version: 5678,
-        },
-        dataSetNames: ['self'],
-      },
-    },
-  },
-};
-
-describe('HashTreeParser', () => {
-  it('should correctly initialize trees from initialLocus data', () => {
-    const parser = new HashTreeParser({initialLocus: exampleInitialLocus, webexRequest: () => Promise.resolve(), locusInfoUpdateCallback : () => {}});
-
-    // Check that the correct number of trees are created
-    expect(Object.keys(parser.dataSets).length).to.equal(3);
-
-    // Verify the 'main' tree
-    const mainTree = parser.dataSets.main.hashTree;
-    expect(mainTree).to.be.instanceOf(HashTree);
-    const expectedMainLeaves = new Array(16).fill(null).map(() => ({}));
-    expectedMainLeaves[0 % 16] = { LOCUS: { 0: { type: 'LOCUS', id: 0, version: 5678 } } };
-    expect(mainTree.leaves).to.deep.equal(expectedMainLeaves);
-    expect(mainTree.numLeaves).to.equal(16);
-
-    // Verify the 'self' tree
-    const selfTree = parser.dataSets.self.hashTree;
-    expect(selfTree).to.be.instanceOf(HashTree);
-    const expectedSelfLeaves = new Array(1).fill(null).map(() => ({}));
-    expectedSelfLeaves[4 % 1] = { SELF: { 4: { type: 'SELF', id: 4, version: 5678 } } };
-    expect(selfTree.leaves).to.deep.equal(expectedSelfLeaves);
-    expect(selfTree.numLeaves).to.equal(1);
-
-    // Verify the 'atd-unmuted' tree
-    const atdUnmutedTree = parser.dataSets['atd-unmuted'].hashTree;
-    expect(atdUnmutedTree).to.be.instanceOf(HashTree);
-    const expectedAtdUnmutedLeaves = new Array(16).fill(null).map(() => ({}));
-    expectedAtdUnmutedLeaves[14 % 16] = { PARTICIPANT: { 14: { type: 'PARTICIPANT', id: 14, version: 5678 } } };
-    expect(atdUnmutedTree.leaves).to.deep.equal(expectedAtdUnmutedLeaves);
-    expect(atdUnmutedTree.numLeaves).to.equal(16);
-
-    // Ensure no other trees were created
-    expect(parser.dataSets['atd-active']).to.be.undefined;
-    expect(parser.dataSets.attendees).to.be.undefined;
-  });
-
-  it('should handle datasets with no corresponding metadata found', () => {
-    const modifiedLocus = JSON.parse(JSON.stringify(exampleInitialLocus));
-    // Remove a participant meta to simulate missing data for 'atd-unmuted'
-    modifiedLocus.locus.participants = []; 
-    // Add a new dataset that won't have corresponding metadata
-    modifiedLocus.dataSets.push({
-        url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/empty-set',
-        root: 'f00f00f00f00f00f00f00f00f00f00f0',
-        version: 1,
-        leafCount: 4,
-        name: 'empty-set',
-    });
-
-
-    const parser = new HashTreeParser({initialLocus: modifiedLocus, webexRequest: () => Promise.resolve(), locusInfoUpdateCallback : () => {}});
-
-    expect(Object.keys(parser.dataSets).length).to.equal(4); // main, self, atd-unmuted (now empty), empty-set
-
-    // 'main' and 'self' should be populated as before
-    const mainTree = parser.dataSets.main.hashTree;
-    const expectedMainLeaves = new Array(16).fill(null).map(() => ({}));
-    expectedMainLeaves[0 % 16] = { LOCUS: { 0: { type: 'LOCUS', id: 0, version: 5678 } } };
-    expect(mainTree.leaves).to.deep.equal(expectedMainLeaves);
-    expect(mainTree.numLeaves).to.equal(16);
-
-    const selfTree = parser.dataSets.self.hashTree;
-    const expectedSelfLeaves = new Array(1).fill(null).map(() => ({}));
-    expectedSelfLeaves[4 % 1] = { SELF: { 4: { type: 'SELF', id: 4, version: 5678 } } };
-    expect(selfTree.leaves).to.deep.equal(expectedSelfLeaves);
-    expect(selfTree.numLeaves).to.equal(1);
-
-    // 'atd-unmuted' metadata was removed from locus, so leaves should be empty
-    const atdUnmutedTree = parser.dataSets['atd-unmuted'].hashTree;
-    expect(atdUnmutedTree).to.be.instanceOf(HashTree);
-    const expectedAtdUnmutedEmptyLeaves = new Array(16).fill(null).map(() => ({}));
-    expect(atdUnmutedTree.leaves).to.deep.equal(expectedAtdUnmutedEmptyLeaves);
-    expect(atdUnmutedTree.numLeaves).to.equal(16); // leafCount from dataSet definition
-
-    // 'empty-set' was added to dataSets but has no metadata in locus
-    const emptySetTree = parser.dataSets['empty-set'].hashTree;
-    expect(emptySetTree).to.be.instanceOf(HashTree);
-    const expectedEmptySetLeaves = new Array(4).fill(null).map(() => ({})); // leafCount is 4
-    expect(emptySetTree.leaves).to.deep.equal(expectedEmptySetLeaves);
-    expect(emptySetTree.numLeaves).to.equal(4);
-  });
-});