@webex/plugin-meetings 3.12.0-next.21 → 3.12.0-next.23

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

@@ -567,6 +567,11 @@ describe('HashTreeParser', () => {
           },
           data: {info: {id: 'some-fake-locus-info'}},
         },
+      ],
+    });
+
+    assert.calledWith(callback, {updateType: LocusInfoUpdateType.OBJECTS_UPDATED,
+      updatedObjects: [
         {
           htMeta: {
             elementId: {
@@ -3775,7 +3780,7 @@ describe('HashTreeParser', () => {
     });
   });
 
-  describe('#resume', () => {
+  describe('#resumeFromMessage', () => {
     const createResumeMessage = (visibleDataSets?, dataSets?) => ({
       locusUrl,
       visibleDataSetsUrl,
@@ -3802,7 +3807,7 @@ describe('HashTreeParser', () => {
 
       expect(parser.state).to.equal('stopped');
 
-      parser.resume(createResumeMessage());
+      parser.resumeFromMessage(createResumeMessage());
 
       expect(parser.state).to.equal('active');
     });
@@ -3811,7 +3816,7 @@ describe('HashTreeParser', () => {
       const parser = createHashTreeParser();
       parser.stop();
 
-      parser.resume({
+      parser.resumeFromMessage({
         locusUrl,
         visibleDataSetsUrl,
         dataSets: [createDataSet('main', 16, 2000)],
@@ -3830,7 +3835,7 @@ describe('HashTreeParser', () => {
         createDataSet('self', 2, 6000),
       ];
 
-      parser.resume(createResumeMessage(undefined, newDataSets));
+      parser.resumeFromMessage(createResumeMessage(undefined, newDataSets));
 
       expect(Object.keys(parser.dataSets)).to.have.lengthOf(2);
       expect(parser.dataSets.main.leafCount).to.equal(8);
@@ -3852,7 +3857,7 @@ describe('HashTreeParser', () => {
         {name: 'self', url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/participant/713e9f99/datasets/self'},
       ];
 
-      parser.resume(createResumeMessage(visibleDataSets, dataSets));
+      parser.resumeFromMessage(createResumeMessage(visibleDataSets, dataSets));
 
       expect(parser.dataSets.main.hashTree).to.be.instanceOf(HashTree);
       expect(parser.dataSets.self.hashTree).to.be.instanceOf(HashTree);
@@ -3866,7 +3871,7 @@ describe('HashTreeParser', () => {
       const handleMessageStub = sinon.stub(parser, 'handleMessage');
 
       const message = createResumeMessage();
-      parser.resume(message);
+      parser.resumeFromMessage(message);
 
       assert.calledOnceWithExactly(handleMessageStub, message, 'on resume');
     });
@@ -3886,7 +3891,7 @@ describe('HashTreeParser', () => {
         {name: 'atd-unmuted', url: 'https://locus-a.wbx2.com/locus/api/v1/loci/97d64a5f/datasets/atd-unmuted'},
       ];
 
-      parser.resume(createResumeMessage(visibleDataSets, dataSets));
+      parser.resumeFromMessage(createResumeMessage(visibleDataSets, dataSets));
 
       expect(parser.visibleDataSets.some((vds) => vds.name === 'atd-unmuted')).to.be.false;
       expect(parser.visibleDataSets.some((vds) => vds.name === 'main')).to.be.true;
@@ -3894,6 +3899,67 @@ describe('HashTreeParser', () => {
     });
   });
 
+  describe('#resumeFromApiResponse', () => {
+    const exampleLocus = {
+      participants: [],
+    } as any;
+
+    it('should set state to active', async () => {
+      const parser = createHashTreeParser();
+      parser.stop();
+
+      expect(parser.state).to.equal('stopped');
+
+      sinon.stub(parser, 'initializeFromGetLociResponse').resolves();
+
+      await parser.resumeFromApiResponse(exampleLocus);
+
+      expect(parser.state).to.equal('active');
+    });
+
+    it('should reset dataSets to empty', async () => {
+      const parser = createHashTreeParser();
+
+      expect(Object.keys(parser.dataSets).length).to.be.greaterThan(0);
+
+      parser.stop();
+
+      sinon.stub(parser, 'initializeFromGetLociResponse').resolves();
+
+      await parser.resumeFromApiResponse(exampleLocus);
+
+      expect(parser.dataSets).to.deep.equal({});
+    });
+
+    it('should call initializeFromGetLociResponse with the provided locus', async () => {
+      const parser = createHashTreeParser();
+      parser.stop();
+
+      const initStub = sinon.stub(parser, 'initializeFromGetLociResponse').resolves();
+
+      await parser.resumeFromApiResponse(exampleLocus);
+
+      assert.calledOnceWithExactly(initStub, exampleLocus);
+    });
+
+    it('should propagate errors from initializeFromGetLociResponse', async () => {
+      const parser = createHashTreeParser();
+      parser.stop();
+
+      const error = new Error('initialization failed');
+      const initStub = sinon.stub(parser, 'initializeFromGetLociResponse').rejects(error);
+
+      let caughtError: Error | undefined;
+      try {
+        await parser.resumeFromApiResponse(exampleLocus);
+      } catch (e) {
+        caughtError = e;
+      }
+
+      expect(caughtError).to.equal(error);
+    });
+  });
+
   describe('#handleLocusUpdate when stopped', () => {
     it('should return early without processing when parser is stopped', () => {
       const parser = createHashTreeParser();
@@ -3929,6 +3995,305 @@ describe('HashTreeParser', () => {
     });
   });
 
+  describe('#syncAllDatasets', () => {
+    it('should sync all datasets that have hash trees in priority order', async () => {
+      const parser = createHashTreeParser();
+
+      // parser starts with main (leafCount=16) and self (leafCount=1) as visible datasets with hash trees
+      // atd-unmuted has no hash tree (not visible)
+      expect(parser.dataSets.main.hashTree).to.be.instanceOf(HashTree);
+      expect(parser.dataSets.self.hashTree).to.be.instanceOf(HashTree);
+
+      const mainUrl = parser.dataSets.main.url;
+      const selfUrl = parser.dataSets.self.url;
+
+      // Mock GET hashtree for main (leafCount > 1, so it does GET first)
+      mockGetHashesFromLocusResponse(
+        mainUrl,
+        new Array(16).fill(EMPTY_HASH),
+        createDataSet('main', 16, 1100)
+      );
+
+      // Mock POST sync for main - return matching root hash so no further sync needed
+      const mainSyncDataSet = createDataSet('main', 16, 1100);
+      mainSyncDataSet.root = parser.dataSets.main.hashTree.getRootHash();
+      mockSendSyncRequestResponse(mainUrl, {
+        dataSets: [mainSyncDataSet],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [],
+      });
+
+      // Mock POST sync for self (leafCount=1, skips GET hashtree)
+      const selfSyncDataSet = createDataSet('self', 1, 2100);
+      selfSyncDataSet.root = parser.dataSets.self.hashTree.getRootHash();
+      mockSendSyncRequestResponse(selfUrl, {
+        dataSets: [selfSyncDataSet],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [],
+      });
+
+      await parser.syncAllDatasets();
+
+      // Verify GET hashtree was called for main only (not self, because leafCount=1)
+      assert.calledWith(webexRequest, sinon.match({method: 'GET', uri: `${mainUrl}/hashtree`}));
+      assert.neverCalledWith(webexRequest, sinon.match({method: 'GET', uri: `${selfUrl}/hashtree`}));
+
+      // Verify POST sync was called for both
+      assert.calledWith(webexRequest, sinon.match({method: 'POST', uri: `${mainUrl}/sync`}));
+      assert.calledWith(webexRequest, sinon.match({method: 'POST', uri: `${selfUrl}/sync`}));
+
+      // Verify main was synced before self (priority order)
+      const mainSyncCallIndex = webexRequest.args.findIndex(
+        (args) => args[0]?.method === 'GET' && args[0]?.uri === `${mainUrl}/hashtree`
+      );
+      const selfSyncCallIndex = webexRequest.args.findIndex(
+        (args) => args[0]?.method === 'POST' && args[0]?.uri === `${selfUrl}/sync`
+      );
+      expect(mainSyncCallIndex).to.be.lessThan(selfSyncCallIndex);
+
+      // Verify isSyncAllInProgress is reset
+      expect(parser.isSyncAllInProgress).to.be.false;
+    });
+
+    it('should return immediately when state is stopped', async () => {
+      const parser = createHashTreeParser();
+      parser.stop();
+
+      await parser.syncAllDatasets();
+
+      // No sync requests should have been made (only the initial sync from constructor)
+      // Reset history to clear constructor calls then verify
+      const callCountBefore = webexRequest.callCount;
+      await parser.syncAllDatasets();
+      assert.equal(webexRequest.callCount, callCountBefore);
+    });
+
+    it('should guard against concurrent calls', async () => {
+      const parser = createHashTreeParser();
+
+      const mainUrl = parser.dataSets.main.url;
+      const selfUrl = parser.dataSets.self.url;
+
+      // Use a deferred promise for the main sync to control timing
+      let resolveMainSync;
+      webexRequest
+        .withArgs(sinon.match({method: 'GET', uri: `${mainUrl}/hashtree`}))
+        .returns(new Promise((resolve) => { resolveMainSync = resolve; }));
+
+      mockSendSyncRequestResponse(mainUrl, {
+        dataSets: [createDataSet('main', 16, 1100)],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [],
+      });
+
+      mockSendSyncRequestResponse(selfUrl, {
+        dataSets: [createDataSet('self', 1, 2100)],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [],
+      });
+
+      // Start first call
+      const promise1 = parser.syncAllDatasets();
+      // Start second call while first is in progress
+      const promise2 = parser.syncAllDatasets();
+
+      // Resolve the pending request
+      resolveMainSync({
+        body: {
+          hashes: new Array(16).fill(EMPTY_HASH),
+          dataSet: createDataSet('main', 16, 1100),
+        },
+      });
+
+      await promise1;
+      await promise2;
+
+      // GET hashtree for main should only be called once (second syncAllDatasets returned immediately)
+      const getHashtreeCalls = webexRequest.args.filter(
+        (args) => args[0]?.method === 'GET' && args[0]?.uri === `${mainUrl}/hashtree`
+      );
+      expect(getHashtreeCalls).to.have.lengthOf(1);
+    });
+
+    it('should skip datasets that do not have a hash tree', async () => {
+      // Create parser with metadata that only has main and self as visible (not atd-unmuted)
+      const metadataWithoutAtd = {
+        ...exampleMetadata,
+        visibleDataSets: exampleMetadata.visibleDataSets.filter((ds) => ds.name !== 'atd-unmuted'),
+      };
+      const parser = createHashTreeParser(exampleInitialLocus, metadataWithoutAtd);
+
+      // atd-unmuted is in dataSets but has no hashTree (not visible)
+      expect(parser.dataSets['atd-unmuted']).to.exist;
+      expect(parser.dataSets['atd-unmuted'].hashTree).to.be.undefined;
+
+      const atdUrl = parser.dataSets['atd-unmuted'].url;
+      const mainUrl = parser.dataSets.main.url;
+      const selfUrl = parser.dataSets.self.url;
+
+      mockGetHashesFromLocusResponse(
+        mainUrl,
+        new Array(16).fill(EMPTY_HASH),
+        createDataSet('main', 16, 1100)
+      );
+
+      const mainSyncDs = createDataSet('main', 16, 1100);
+      mainSyncDs.root = parser.dataSets.main.hashTree.getRootHash();
+      mockSendSyncRequestResponse(mainUrl, {
+        dataSets: [mainSyncDs],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [],
+      });
+
+      const selfSyncDs = createDataSet('self', 1, 2100);
+      selfSyncDs.root = parser.dataSets.self.hashTree.getRootHash();
+      mockSendSyncRequestResponse(selfUrl, {
+        dataSets: [selfSyncDs],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [],
+      });
+
+      await parser.syncAllDatasets();
+
+      // No requests should have been made for atd-unmuted
+      assert.neverCalledWith(webexRequest, sinon.match({uri: sinon.match(atdUrl)}));
+    });
+  });
+
+  describe('#handleMessage sync queue', () => {
+    it('should deduplicate: not sync the same dataset twice when enqueued multiple times', async () => {
+      const parser = createHashTreeParser();
+
+      const mainUrl = parser.dataSets.main.url;
+
+      // Setup mocks before triggering syncs
+      mockGetHashesFromLocusResponse(
+        mainUrl,
+        new Array(16).fill(EMPTY_HASH),
+        createDataSet('main', 16, 1101)
+      );
+
+      const mainSyncDs = createDataSet('main', 16, 1101);
+      mainSyncDs.root = parser.dataSets.main.hashTree.getRootHash();
+      mockSendSyncRequestResponse(mainUrl, {
+        dataSets: [mainSyncDs],
+        visibleDataSetsUrl,
+        locusUrl,
+        locusStateElements: [],
+      });
+
+      // Send two heartbeat messages (no locusStateElements) with different root hashes for main
+      parser.handleMessage(createHeartbeatMessage('main', 16, 1100, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1'), 'first');
+      parser.handleMessage(createHeartbeatMessage('main', 16, 1101, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa2'), 'second');
+
+      // The second call resets the timer. After 1000ms, only one sync fires.
+      await clock.tickAsync(1000);
+
+      // Only one GET hashtree call should have been made for main
+      const getHashtreeCalls = webexRequest.args.filter(
+        (args) => args[0]?.method === 'GET' && args[0]?.uri === `${mainUrl}/hashtree`
+      );
+      expect(getHashtreeCalls).to.have.lengthOf(1);
+    });
+
+    it('should stop processing the sync queue when parser is stopped mid-queue', async () => {
+      const parser = createHashTreeParser();
+
+      const mainUrl = parser.dataSets.main.url;
+      const selfUrl = parser.dataSets.self.url;
+
+      // Mock main GET hashtree with a deferred promise so we can control when it resolves
+      let resolveMainHashtree;
+      webexRequest
+        .withArgs(sinon.match({method: 'GET', uri: `${mainUrl}/hashtree`}))
+        .callsFake(() => new Promise((resolve) => { resolveMainHashtree = resolve; }));
+
+      // Send a heartbeat message that triggers sync timers for both main and self
+      parser.handleMessage(
+        createHeartbeatMessage('main', 16, 1100, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1'),
+        'trigger main sync'
+      );
+      parser.handleMessage(
+        createHeartbeatMessage('self', 1, 2100, 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb1'),
+        'trigger self sync'
+      );
+
+      // Fire the timers - main sync starts (calls GET hashtree, which blocks)
+      await clock.tickAsync(1000);
+
+      // Stop the parser while main sync is in progress
+      parser.stop();
+
+      // Resolve the pending main GET request
+      resolveMainHashtree({
+        body: {
+          hashes: new Array(16).fill(EMPTY_HASH),
+          dataSet: createDataSet('main', 16, 1100),
+        },
+      });
+
+      await clock.tickAsync(0);
+
+      // Self sync should NOT have been triggered because parser was stopped
+      assert.neverCalledWith(webexRequest, sinon.match({method: 'POST', uri: `${selfUrl}/sync`}));
+      assert.neverCalledWith(webexRequest, sinon.match({method: 'GET', uri: `${selfUrl}/hashtree`}));
+    });
+  });
+
+  describe('#stop sync queue', () => {
+    it('should clear the syncQueue when stopped so remaining queued items are not processed', async () => {
+      const parser = createHashTreeParser();
+
+      const mainUrl = parser.dataSets.main.url;
+      const selfUrl = parser.dataSets.self.url;
+
+      // Mock main GET hashtree with a deferred promise so we can control when it resolves
+      let resolveMainHashtree;
+      webexRequest
+        .withArgs(sinon.match({method: 'GET', uri: `${mainUrl}/hashtree`}))
+        .callsFake(() => new Promise((resolve) => { resolveMainHashtree = resolve; }));
+
+      // Enqueue syncs for both main and self by sending heartbeat messages
+      parser.handleMessage(
+        createHeartbeatMessage('main', 16, 1100, 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa1'),
+        'trigger main sync'
+      );
+      parser.handleMessage(
+        createHeartbeatMessage('self', 1, 2100, 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb1'),
+        'trigger self sync'
+      );
+
+      // Fire the timers - main sync starts and blocks on GET hashtree
+      await clock.tickAsync(1000);
+
+      // Verify that self is still in the queue (main is being processed, self is waiting)
+      // Now stop the parser - this should clear the syncQueue
+      parser.stop();
+
+      // Resolve the pending main GET request so the in-flight sync can finish
+      resolveMainHashtree({
+        body: {
+          hashes: new Array(16).fill(EMPTY_HASH),
+          dataSet: createDataSet('main', 16, 1100),
+        },
+      });
+
+      await clock.tickAsync(0);
+
+      // Self should never have been synced because stop() cleared the queue
+      const selfGetCalls = webexRequest.args.filter(
+        (args) => args[0]?.method === 'GET' && args[0]?.uri === `${selfUrl}/hashtree`
+      );
+      expect(selfGetCalls).to.have.lengthOf(0);
+    });
+  });
+
   describe('#cleanUp', () => {
     it('should stop the parser, clear all timers and clear all dataSets', () => {
       const parser = createHashTreeParser();

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

@@ -36,6 +36,27 @@ describe('plugin-meetings', () => {
                 uri: `https://locus-test.webex.com/locus/api/v1/loci/call`,
                 body: 'foo'
                 };
+
+            const hashTreeOptions = {
+              method: 'GET',
+              headers: {
+                trackingid: 'test',
+                'retry-after': 1000,
+              },
+              uri: `https://locus-test.webex.com/locus/api/v1/loci/12345/session/abc/datasets/main/hashtree`,
+              body: undefined,
+            };
+
+            const syncOptions = {
+              method: 'POST',
+              headers: {
+                trackingid: 'test',
+                'retry-after': 1000,
+              },
+              uri: `https://locus-test.webex.com/locus/api/v1/loci/12345/session/abc/datasets/main/sync`,
+              body: 'foo',
+            };
+
             const reason1 = new WebexHttpError.MethodNotAllowed({
                 statusCode: 403,
                 options: {
@@ -68,14 +89,194 @@ describe('plugin-meetings', () => {
             });
 
             it('calls handleRetryRequestLocusServiceError with correct retry time when locus service unavailable error', () => {
-                interceptor.webex.request = sinon.stub().returns(Promise.resolve());
-                const handleRetryStub = sinon.stub(interceptor, 'handleRetryRequestLocusServiceError');
+              interceptor.webex.request = sinon.stub().returns(Promise.resolve());
+              const handleRetryStub = sinon.stub(
+                interceptor,
+                'handleRetryRequestLocusServiceError'
+              );
+              handleRetryStub.returns(Promise.resolve());
+
+              return interceptor.onResponseError(options, reason2).then(() => {
+                expect(handleRetryStub.calledWith(options, 1000)).to.be.true;
+              });
+            });
+
+            [429, 500, 502, 503, 504].forEach((statusCode) => {
+              it(`does not retry /hashtree requests on ${statusCode}`, () => {
+                const reason = new WebexHttpError.MethodNotAllowed({
+                  statusCode,
+                  options: {
+                    headers: {trackingid: 'test', 'retry-after': 1000},
+                    uri: hashTreeOptions.uri,
+                  },
+                  body: {error: `Fake ${statusCode}`},
+                });
+
+                const handleRetryStub = sinon.stub(
+                  interceptor,
+                  'handleRetryRequestLocusServiceError'
+                );
+                handleRetryStub.returns(Promise.resolve());
+
+                return interceptor.onResponseError(hashTreeOptions, reason).then(
+                  () => assert.fail('Expected promise to be rejected'),
+                  (err) => {
+                    expect(err).to.equal(reason);
+                    expect(handleRetryStub.called).to.be.false;
+                    handleRetryStub.restore();
+                  }
+                );
+              });
+
+              it(`does not retry /sync requests on ${statusCode}`, () => {
+                const reason = new WebexHttpError.MethodNotAllowed({
+                  statusCode,
+                  options: {
+                    headers: {trackingid: 'test', 'retry-after': 1000},
+                    uri: syncOptions.uri,
+                  },
+                  body: {error: `Fake ${statusCode}`},
+                });
+
+                const handleRetryStub = sinon.stub(
+                  interceptor,
+                  'handleRetryRequestLocusServiceError'
+                );
                 handleRetryStub.returns(Promise.resolve());
 
-                return interceptor.onResponseError(options, reason2).then(() => {
-                    expect(handleRetryStub.calledWith(options, 1000)).to.be.true;
+                return interceptor.onResponseError(syncOptions, reason).then(
+                  () => assert.fail('Expected promise to be rejected'),
+                  (err) => {
+                    expect(err).to.equal(reason);
+                    expect(handleRetryStub.called).to.be.false;
+                    handleRetryStub.restore();
+                  }
+                );
+              });
+            });
+
+            it('still retries other locus requests on 429', () => {
+              const reason429 = new WebexHttpError.MethodNotAllowed({
+                statusCode: 429,
+                options: {
+                  headers: {trackingid: 'test', 'retry-after': 1000},
+                  uri: options.uri,
+                },
+                body: {error: 'Too Many Requests'},
+              });
+
+              interceptor.webex.request = sinon.stub().returns(Promise.resolve());
+              const handleRetryStub = sinon.stub(
+                interceptor,
+                'handleRetryRequestLocusServiceError'
+              );
+              handleRetryStub.returns(Promise.resolve());
 
+              return interceptor.onResponseError(options, reason429).then(() => {
+                expect(handleRetryStub.calledOnce).to.be.true;
+                handleRetryStub.restore();
+              });
+            });
+
+            it('still retries other locus requests on 503', () => {
+              interceptor.webex.request = sinon.stub().returns(Promise.resolve());
+              const handleRetryStub = sinon.stub(
+                interceptor,
+                'handleRetryRequestLocusServiceError'
+              );
+              handleRetryStub.returns(Promise.resolve());
+
+              return interceptor.onResponseError(options, reason2).then(() => {
+                expect(handleRetryStub.calledOnce).to.be.true;
+                handleRetryStub.restore();
+              });
+            });
+
+            describe('URI parsing edge cases', () => {
+              const make503Reason = (uri) =>
+                new WebexHttpError.MethodNotAllowed({
+                  statusCode: 503,
+                  options: {headers: {trackingid: 'test', 'retry-after': 1000}, uri},
+                  body: {error: 'Service Unavailable'},
+                });
+
+              const makeOptions = (uri) => ({
+                method: 'GET',
+                headers: {trackingid: 'test', 'retry-after': 1000},
+                uri,
+                body: undefined,
+              });
+
+              [
+                'https://locus.webex.com/locus/api/v1/loci/123/session/abc/datasets/main/hashtree?rootHash=xyz',
+                'https://locus.webex.com/locus/api/v1/loci/123/session/abc/datasets/main/sync?seq=5',
+              ].forEach((uri) => {
+                it(`skips retry even with query params: ${uri.split('/').pop()}`, () => {
+                  const opts = makeOptions(uri);
+                  const reason = make503Reason(uri);
+                  const stub = sinon
+                    .stub(interceptor, 'handleRetryRequestLocusServiceError')
+                    .returns(Promise.resolve());
+
+                  return interceptor.onResponseError(opts, reason).then(
+                    () => assert.fail('Expected promise to be rejected'),
+                    (err) => {
+                      expect(err).to.equal(reason);
+                      expect(stub.called).to.be.false;
+                      stub.restore();
+                    }
+                  );
                 });
+              });
+
+              [
+                'https://locus.webex.com/locus/api/v1/loci/123/hashtree-v2',
+                'https://locus.webex.com/locus/api/v1/loci/123/syncData',
+                'https://locus.webex.com/locus/api/v1/loci/123/async',
+                'https://locus.webex.com/locus/api/v1/loci/123/hashtree/metadata',
+              ].forEach((uri) => {
+                it(`still retries when path only partially matches: ${uri
+                  .split('/')
+                  .pop()}`, () => {
+                  const opts = makeOptions(uri);
+                  const reason = make503Reason(uri);
+                  interceptor.webex.request = sinon.stub().returns(Promise.resolve());
+                  const stub = sinon
+                    .stub(interceptor, 'handleRetryRequestLocusServiceError')
+                    .returns(Promise.resolve());
+
+                  return interceptor.onResponseError(opts, reason).then(() => {
+                    expect(stub.calledOnce).to.be.true;
+                    stub.restore();
+                  });
+                });
+              });
+
+              it('still retries when /hashtree is on a non-locus host', () => {
+                const uri = 'https://other-service.webex.com/api/v1/hashtree';
+                const opts = makeOptions(uri);
+                const reason = make503Reason(uri);
+
+                return interceptor.onResponseError(opts, reason).then(
+                  () => assert.fail('Expected promise to be rejected'),
+                  (err) => {
+                    expect(err).to.equal(reason);
+                  }
+                );
+              });
+
+              it('still retries when URI is malformed', () => {
+                const uri = 'not-a-valid-url';
+                const opts = makeOptions(uri);
+                const reason = make503Reason(uri);
+
+                return interceptor.onResponseError(opts, reason).then(
+                  () => assert.fail('Expected promise to be rejected'),
+                  (err) => {
+                    expect(err).to.equal(reason);
+                  }
+                );
+              });
             });
         });