@webex/plugin-meetings 3.8.1-web-workers-keepalive.1 → 3.9.0-webinar5k.1

package/src/multistream/sendSlotManager.ts

@@ -7,10 +7,20 @@ import {
   StreamState,
 } from '@webex/internal-media-core';
 
+/**
+ * This class is used to manage the sendSlots for the given media types.
+ */
 export default class SendSlotManager {
   private readonly slots: Map<MediaType, SendSlot> = new Map();
   private readonly LoggerProxy: any;
+  private readonly sourceStateOverrides: Map<MediaType, StreamState> = new Map();
 
+  /**
+   * Constructor for SendSlotManager
+   *
+   * @param {any} LoggerProxy is used to log the messages
+   * @constructor
+   */
   constructor(LoggerProxy: any) {
     this.LoggerProxy = LoggerProxy;
   }
@@ -93,7 +103,7 @@ export default class SendSlotManager {
   public setSourceStateOverride(mediaType: MediaType, state: StreamState | null) {
     if (mediaType !== MediaType.VideoMain) {
       throw new Error(
-        `sendSlotManager cannot set source state override which media type is ${mediaType}`
+        `Invalid media type '${mediaType}'. Source state overrides are only applicable to ${MediaType.VideoMain}.`
       );
     }
 
@@ -103,17 +113,39 @@ export default class SendSlotManager {
       throw new Error(`Slot for ${mediaType} does not exist`);
     }
 
+    const currentStateOverride = this.getSourceStateOverride(mediaType);
+    if (currentStateOverride === state) {
+      return;
+    }
+
     if (state) {
       slot.setSourceStateOverride(state);
+      this.sourceStateOverrides.set(mediaType, state);
     } else {
       slot.clearSourceStateOverride();
+      this.sourceStateOverrides.delete(mediaType);
     }
 
     this.LoggerProxy.logger.info(
-      `SendSlotsManager->setSourceStateOverride#set source state override for ${mediaType} to ${state}`
+      `SendSlotManager->setSourceStateOverride#set source state override for ${mediaType} to ${state}`
     );
   }
 
+  /**
+   * Gets the source state override for the given media type.
+   * @param {MediaType} mediaType - The type of media to get the source state override for.
+   * @returns {StreamState | null} - The current source state override or null if not set.
+   */
+  private getSourceStateOverride(mediaType: MediaType): StreamState | null {
+    if (mediaType !== MediaType.VideoMain) {
+      throw new Error(
+        `Invalid media type '${mediaType}'. Source state overrides are only applicable to ${MediaType.VideoMain}.`
+      );
+    }
+
+    return this.sourceStateOverrides.get(mediaType) || null;
+  }
+
   /**
    * This method publishes the given stream to the sendSlot for the given mediaType
    * @param {MediaType} mediaType MediaType of the sendSlot to which a stream needs to be published (AUDIO_MAIN/VIDEO_MAIN/AUDIO_SLIDES/VIDEO_SLIDES)

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

@@ -0,0 +1,394 @@
+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

@@ -0,0 +1,156 @@
+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);
+  });
+});