@internetarchive/ia-book-actions 1.4.3 → 1.4.4-alpha10

package/test/core/services/actions-handler.test.js

@@ -1,7 +1,9 @@
-import { expect, fixture } from '@open-wc/testing';
+import { expect, fixture, aTimeout } from '@open-wc/testing';
 import sinon from 'sinon';
+import { LocalCache } from '@internetarchive/local-cache';
 
 import ActionsHandler from '../../../src/core/services/actions-handler/actions-handler.js';
+import { analyticsCategories, analyticsActions, analyticsLabels } from '../../../src/core/config/analytics-event-and-category.js';
 
 // Define a temporary tag for this element for testing
 const TEST_TAG = 'ia-actions-handler-test';
@@ -89,3 +91,110 @@ describe('ActionsHandler#setStickyAdminAccess', () => {
     expect(lastSetCookie).to.contain(`${encodeURIComponent('sticky-admin-access')}=${encodeURIComponent('false')}`);
   });
 });
+
+describe('ActionsHandler#handleLoanRenewNow (WEBDEV-8322)', () => {
+  let el;
+  let localCache;
+  const identifier = 'renew-now-test-book';
+
+  beforeEach(async () => {
+    // Make sure no other test in this run left ?error=true in the URL —
+    // ActionsHandlerService reads it directly off window.location.
+    const params = new URLSearchParams(window.location.search);
+    if (params.has('error')) {
+      params.delete('error');
+      const query = params.toString();
+      window.history.replaceState(
+        {},
+        '',
+        `${window.location.pathname}${query ? `?${query}` : ''}`
+      );
+    }
+
+    el = await fixture(`<${TEST_TAG}></${TEST_TAG}>`);
+    el.identifier = identifier;
+    el.loanTotalTime = 3600;
+    localCache = new LocalCache({ namespace: 'loanRenew' });
+    el.localCache = localCache;
+    // The demo/test environment's ActionsHandlerService fakes a renew_loan
+    // success after a 5s delay to simulate a real network round-trip.
+    await localCache.delete(`${identifier}-loanTime`);
+  });
+
+  afterEach(() => {
+    sinon.restore();
+  });
+
+  it('awaits the loanTime cache write before dispatching loanAutoRenewed, and fires the renew analytics event only on success', async function test() {
+    this.timeout(7000);
+
+    const storeStatsSpy = sinon.spy(el.loanAnanlytics, 'storeLoanStatsCount');
+    const sendEventSpy = sinon.spy(el.loanAnanlytics, 'sendEvent');
+
+    let loanTimeWhenEventFired;
+    el.addEventListener('loanAutoRenewed', () => {
+      loanTimeWhenEventFired = localCache.get(`${identifier}-loanTime`);
+    });
+
+    el.handleLoanRenewNow('auto');
+
+    // ActionsHandlerService fakes a 5s delay for renew_loan in this
+    // (localhost) test environment — wait it out, matching the existing
+    // pattern used elsewhere in this test suite for the same fake delay.
+    await aTimeout(5500);
+
+    // The race this guards against: loanAutoRenewed used to dispatch
+    // before setBrowseTimeSession()'s cache write landed, so a listener
+    // reading the cache immediately could still see the old/deleted value.
+    const resolvedLoanTime = await loanTimeWhenEventFired;
+    expect(resolvedLoanTime).to.exist;
+    expect(resolvedLoanTime.getTime()).to.be.greaterThan(Date.now());
+
+    expect(storeStatsSpy.calledWith(identifier, 'autorenew')).to.be.true;
+    // storeLoanStatsCount fires its own matrix-stats sendEvent internally,
+    // so assert on the specific renew-success event rather than call count.
+    expect(
+      sendEventSpy.calledWith(
+        analyticsCategories.browse,
+        analyticsActions.browseRenew,
+        analyticsLabels.browseAutoRenew,
+        identifier
+      )
+    ).to.be.true;
+  });
+
+  it('does not fire the renew analytics event when the renewal fails', async () => {
+    const sendEventSpy = sinon.spy(el.loanAnanlytics, 'sendEvent');
+    const storeStatsSpy = sinon.spy(el.loanAnanlytics, 'storeLoanStatsCount');
+
+    // Force ActionsHandlerService's shouldReturnError branch for this call.
+    const originalSearch = window.location.search;
+    const params = new URLSearchParams(originalSearch);
+    params.set('error', 'true');
+    window.history.pushState({}, '', `?${params.toString()}`);
+
+    let errorEventDetail;
+    el.addEventListener('lendingActionError', ({ detail }) => {
+      errorEventDetail = detail;
+    });
+
+    try {
+      el.handleLoanRenewNow('auto');
+      await aTimeout(200);
+
+      expect(errorEventDetail?.action).to.equal('renew_loan');
+      // dispatchActionError fires its own 'LendingServiceError' analytics
+      // event on any error — that's expected. What must NOT fire is the
+      // renew-success event this fix gates on `isRenewal`.
+      expect(
+        sendEventSpy.calledWith(
+          analyticsCategories.browse,
+          analyticsActions.browseRenew
+        )
+      ).to.be.false;
+      expect(storeStatsSpy.calledWith(identifier, 'autorenew')).to.be.false;
+    } finally {
+      window.history.pushState({}, '', `${window.location.pathname}${originalSearch}`);
+    }
+  });
+});

package/test/core/services/loan-renew-helper.test.js

@@ -80,7 +80,7 @@ describe('Loan Renew Determine', () => {
     );
 
     expect(toastMsg).to.be.equal(
-      'With no action, this book will be auto-returned in 2 minutes.'
+      'Go to any other page to keep your loan active.'
     );
   });
 });

package/test/core/services/loan-token-poller.test.js

@@ -56,3 +56,79 @@ describe('Get Loan Token', () => {
     expect(tokenPoller.loanTokenInterval).to.equal(undefined);
   });
 });
+
+describe('handleTokenError retry (WEBDEV-8322 follow-up)', () => {
+  // Lending::do_renew() (backend) deletes the old loan record and writes
+  // a brand-new one on every renewal, so the initial create_token call
+  // right after a renewal can race that write's propagation and come
+  // back with this exact error even though the loan is genuinely valid.
+  const staleLoanReadError = {
+    error: 'You do not currently have this book borrowed.',
+  };
+
+  const makeTokenPoller = () =>
+    new LoanTokenPoller(
+      'identifier1',
+      'browsed',
+      () => {},
+      () => {},
+      2000
+    );
+
+  it('retries the initial call on a stale-loan-read error instead of failing immediately', () => {
+    const tokenPoller = makeTokenPoller();
+    const handleLoanTokenPollerSpy = Sinon.spy(
+      tokenPoller,
+      'handleLoanTokenPoller'
+    );
+    const errorCallbackSpy = Sinon.spy(tokenPoller, 'errorCallback');
+    const clock = Sinon.useFakeTimers();
+
+    try {
+      tokenPoller.handleTokenError(staleLoanReadError, true, 0);
+
+      expect(errorCallbackSpy.called).to.be.false;
+
+      clock.tick(tokenPoller.initialTokenRetryDelay);
+
+      expect(handleLoanTokenPollerSpy.calledWith(true, 1)).to.be.true;
+    } finally {
+      clock.restore();
+    }
+  });
+
+  it('gives up and calls errorCallback after exhausting retries', () => {
+    const tokenPoller = makeTokenPoller();
+    const errorCallbackSpy = Sinon.spy(tokenPoller, 'errorCallback');
+
+    tokenPoller.handleTokenError(
+      staleLoanReadError,
+      true,
+      tokenPoller.maxInitialTokenRetries
+    );
+
+    expect(errorCallbackSpy.calledOnce).to.be.true;
+  });
+
+  it('does not retry a routine (non-initial) poll on the same error', () => {
+    const tokenPoller = makeTokenPoller();
+    const errorCallbackSpy = Sinon.spy(tokenPoller, 'errorCallback');
+
+    tokenPoller.handleTokenError(staleLoanReadError, false, 0);
+
+    expect(errorCallbackSpy.calledOnce).to.be.true;
+  });
+
+  it('does not retry a genuinely different error, even on the initial call', () => {
+    const tokenPoller = makeTokenPoller();
+    const errorCallbackSpy = Sinon.spy(tokenPoller, 'errorCallback');
+
+    tokenPoller.handleTokenError(
+      { error: 'loan token not found. please try again later.' },
+      true,
+      0
+    );
+
+    expect(errorCallbackSpy.calledOnce).to.be.true;
+  });
+});