@internetarchive/ia-book-actions 1.4.6-alpha1 → 1.4.6-alpha3

package/package.json

@@ -7,7 +7,7 @@
   },
   "author": "Internet Archive",
   "license": "AGPL-3.0-only",
-  "version": "1.4.6-alpha1",
+  "version": "1.4.6-alpha3",
   "main": "index.js",
   "module": "index.js",
   "publishConfig": {

package/src/core/services/actions-handler/actions-handler-service.js

@@ -131,11 +131,12 @@ export default async function ActionsHandlerService(options) {
     });
 
     /**
-     * Report it, don't just swallow it. A rejected fetch (offline, dropped
-     * connection) lands here — a non-JSON body no longer does, see
-     * parseServiceResponse() — as does anything thrown after the response
-     * arrived; calling neither `success` nor `error` leaves every caller
-     * waiting on a callback that never comes. Only the former is a network
+     * Report it, don't just swallow it. This catches a rejected fetch
+     * (offline, dropped or blocked connection) and anything thrown after the
+     * response arrived, including by the caller's own callbacks. Non-JSON
+     * bodies are handled in parseServiceResponse() and don't reach here.
+     * Calling neither `success` nor `error` would leave every caller waiting
+     * on a callback that never comes. Only a rejected fetch is a network
      * problem, so only that one says so.
      *
      * For renew_loan that's not merely a missing modal: IABookActions
@@ -145,9 +146,13 @@ export default async function ActionsHandlerService(options) {
      * connection is exactly when this fires.
      */
     log(`[IABookActions] ✗ ${option.action} threw`, error);
+    // networkFailure marks "the service never answered" (like
+    // nonJsonResponse in parseServiceResponse) — see
+    // IABookActions.handleLendingActionError.
     option?.error?.({
       error: reachedResponse ? unexpectedError : networkError,
       detail: String(error),
+      ...(reachedResponse ? {} : { networkFailure: true }),
     });
   }
 }
@@ -167,16 +172,15 @@ export async function parseServiceResponse(response, option) {
   const { status } = response;
   const contentType = response.headers?.get('content-type') || '';
 
-  // The service always answers with JSON (application/json, or
-  // application/problem+json for OPDS) — anything else never came from it.
+  // The service always answers with JSON; a body that doesn't parse never
+  // came from it. Parsed regardless of Content-Type, so a valid answer is
+  // never mistaken for an error page if a header is ever missing.
   const body = await response.text();
   let data;
-  if (contentType.includes('json')) {
-    try {
-      data = JSON.parse(body);
-    } catch (parseError) {
-      data = undefined;
-    }
+  try {
+    data = JSON.parse(body);
+  } catch (parseError) {
+    data = undefined;
   }
 
   if (data === undefined) {

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

@@ -47,6 +47,13 @@ export class LoanTokenPoller {
 
     this.loanTokenInterval = undefined;
 
+    /**
+     * create_token failures in a row since the last success, passed to
+     * errorCallback so the consumer can tell a one-off blip from a run of
+     * them — see IABookActions.handleLendingActionError.
+     */
+    this.consecutiveFailures = 0;
+
     /**
      * loan analytics instance
      * @see loan-analytics.js
@@ -63,12 +70,9 @@ export class LoanTokenPoller {
   async bookAccessed() {
     if (this.borrowType) {
       if (this.skipInitialCall) {
-        log(
-          '[LoanTokenPoller] skipping initial create_token — already minted by the renewal response',
-          {
-            identifier: this.identifier,
-          }
-        );
+        log('[LoanTokenPoller] skipping initial create_token — already minted by the renewal response', {
+          identifier: this.identifier,
+        });
       } else {
         // Do an initial token, then set an interval
         this.handleLoanTokenPoller(true);
@@ -116,6 +120,7 @@ export class LoanTokenPoller {
           identifier: this.identifier,
           isInitial,
         });
+        this.consecutiveFailures = 0;
         if (isInitial) this.successCallback();
       },
     });
@@ -133,17 +138,23 @@ export class LoanTokenPoller {
    */
   handleTokenError(data, isInitial) {
     const action = 'create_token';
+    this.consecutiveFailures += 1;
+    const { consecutiveFailures } = this;
 
     log('[LoanTokenPoller] create_token failed', {
       identifier: this.identifier,
       isInitial,
+      consecutiveFailures,
       error: data?.error,
     });
 
-    // isInitial rides along so the consumer can distinguish "the book won't
-    // open at all" from "a mid-read refresh blipped" — see
+    // isInitial and consecutiveFailures ride along so the consumer can
+    // distinguish "the book won't open at all" from "a mid-read refresh
+    // blipped", and a one-off blip from a run of them — see
     // IABookActions.handleLendingActionError.
-    this.errorCallback({ detail: { action, data, isInitial } });
+    this.errorCallback({
+      detail: { action, data, isInitial, consecutiveFailures },
+    });
 
     // send error to Sentry
     sentryCaptureMessage(
@@ -154,6 +165,7 @@ export class LoanTokenPoller {
         extra: {
           borrowType: this.borrowType,
           isInitial,
+          consecutiveFailures,
           error: data?.error,
           status: data?.status,
           nonJsonResponse: data?.nonJsonResponse === true,

package/src/ia-book-actions.js

@@ -42,6 +42,16 @@ export const modalButtonStyle = {
     'background:none;font-size:inherit;border:0;padding:0;color:#0000ee;cursor:pointer;text-decoration:underline',
 };
 
+/**
+ * How many create_token refreshes in a row may fail without an answer from
+ * the service before the patron is shown the error modal. Each successful
+ * refresh mints an access token good for 10 minutes (petabox
+ * LendingConfig::BOOKREADER_AUTH_SECONDS) and refreshes run every 2 minutes
+ * (tokenDelay), so the 3rd failure in a row (~6 minutes on) still shows the
+ * modal before that token runs out and pages stop loading.
+ */
+export const MAX_SILENT_TOKEN_REFRESH_FAILURES = 2;
+
 export default class IABookActions extends LitElement {
   static get properties() {
     return {
@@ -1014,36 +1024,44 @@ export default class IABookActions extends LitElement {
       recoveringFromLoanExpiry: this.recoveringFromLoanExpiry,
     });
 
+    const consecutiveFailures = event?.detail?.consecutiveFailures ?? 1;
     if (
       action === 'create_token' &&
       !isInitial &&
-      eventData?.nonJsonResponse === true &&
-      eventData?.status === 400
+      (eventData?.nonJsonResponse === true ||
+        eventData?.networkFailure === true) &&
+      consecutiveFailures <= MAX_SILENT_TOKEN_REFRESH_FAILURES
     ) {
-      // Something in front of the service (the WAF's /about/400.html)
-      // answered a routine refresh instead of the service itself. It's
-      // already reported to Sentry (ActionsHandlerService/LoanTokenPoller);
-      // the current access token keeps the book readable, and the poll
-      // interval is left running, so the next tick tries again. No modal,
-      // and no session teardown.
+      // The service never answered this routine refresh: something in
+      // front of it did (the WAF's /about/400.html, an outage page), or the
+      // request never got through. That says nothing about the loan, so
+      // no modal and no session teardown — it's already reported to Sentry
+      // (ActionsHandlerService/LoanTokenPoller), the current access token
+      // keeps the book readable, and the poll interval is left running, so
+      // the next tick tries again. The service's own answer (e.g. "You do
+      // not currently have this book borrowed.") still falls through below.
       //
       // Not for the initial call: its success is what runs
       // lendingBarPostInit() and opens the book (see startLoanTokenPoller),
       // so suppressing it would leave a reader that never loads, silently.
+      //
+      // And not forever: past MAX_SILENT_TOKEN_REFRESH_FAILURES in a row,
+      // the last good access token is about to expire, so fall through to
+      // the modal rather than let the reader break with nothing shown.
       log(
-        '[IABookActions] create_token HTML 400 on a routine refresh — no modal',
+        '[IABookActions] create_token routine refresh got no answer from the service — no modal',
         {
           identifier: this.identifier,
           status: eventData?.status,
+          errorMsg,
         }
       );
       return;
     }
 
     if (action === 'create_token') {
-      // Any other create_token failure — initial or a routine interval
-      // refresh, except the routine HTML 400 above — means access can no
-      // longer be confirmed (e.g. a stale loan-record
+      // Any other create_token failure — initial, or a routine refresh the
+      // service itself answered — means access can no longer be confirmed (e.g. a stale loan-record
       // cache on some other node can make this request fail even though
       // the loan is fine, or the loan may genuinely have just been
       // returned via BookReaderImages.php's revokeAccess()). Don't retry

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

@@ -59,6 +59,17 @@ describe('ActionsHandlerService#parseServiceResponse', () => {
     expect(context.extra.bodySnippet).to.contain('<!DOCTYPE');
   });
 
+  it("treats a JSON body as the service's answer even without a JSON content type", async () => {
+    const body = { success: true, token: 'abc' };
+    const response = new Response(JSON.stringify(body), {
+      status: 200,
+      headers: { 'Content-Type': 'text/html' },
+    });
+
+    expect(await parseServiceResponse(response, option)).to.deep.equal(body);
+    expect(window.Sentry.captureMessage.called).to.be.false;
+  });
+
   it('treats a JSON content type with an unparseable body as non-JSON', async () => {
     const response = new Response('<!DOCTYPE html>', {
       status: 502,
@@ -135,6 +146,7 @@ describe('ActionsHandlerService - thrown errors', () => {
 
     expect(error.calledOnce).to.be.true;
     expect(error.firstCall.args[0].error).to.equal(networkError);
+    expect(error.firstCall.args[0].networkFailure).to.be.true;
     const [, context] = window.Sentry.captureException.firstCall.args;
     expect(context.tags).to.deep.equal({
       identifier: 'foo',
@@ -158,5 +170,7 @@ describe('ActionsHandlerService - thrown errors', () => {
     expect(error.calledOnce).to.be.true;
     expect(error.firstCall.args[0].error).to.equal(unexpectedError);
     expect(error.firstCall.args[0].detail).to.contain('boom');
+    // the service did answer, so this isn't treated as "no answer"
+    expect(error.firstCall.args[0].networkFailure).to.be.undefined;
   });
 });

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

@@ -1,4 +1,4 @@
-import { expect } from '@open-wc/testing';
+import { expect, aTimeout } from '@open-wc/testing';
 import Sinon from 'sinon';
 
 import { LoanTokenPoller } from '../../../src/core/services/loan-token-poller.js';
@@ -223,3 +223,46 @@ describe('handleTokenError - HTML 400 from the WAF (WEBDEV-9595)', () => {
     poller.disconnectedCallback();
   });
 });
+
+describe('consecutive create_token failures (WEBDEV-9595)', () => {
+  const makePoller = errorCallback =>
+    new LoanTokenPoller({
+      identifier: 'identifier1',
+      borrowType: 'borrowed',
+      successCallback: () => {},
+      errorCallback,
+      pollerDelay: 120,
+      skipInitialCall: true,
+    });
+
+  it('passes the count of failures in a row to errorCallback', () => {
+    const errorCallback = Sinon.spy();
+    const poller = makePoller(errorCallback);
+
+    poller.handleTokenError({ error: 'x' }, false);
+    poller.handleTokenError({ error: 'x' }, false);
+    poller.handleTokenError({ error: 'x' }, false);
+
+    expect(
+      errorCallback.getCalls().map(c => c.args[0].detail.consecutiveFailures)
+    ).to.deep.equal([1, 2, 3]);
+    poller.disconnectedCallback();
+  });
+
+  it('resets the count after a successful refresh', async () => {
+    const errorCallback = Sinon.spy();
+    const poller = makePoller(errorCallback);
+
+    poller.handleTokenError({ error: 'x' }, false);
+    poller.handleTokenError({ error: 'x' }, false);
+    // on localhost the service fakes a create_token success
+    poller.handleLoanTokenPoller(false);
+    await aTimeout(300);
+    poller.handleTokenError({ error: 'x' }, false);
+
+    expect(errorCallback.lastCall.args[0].detail.consecutiveFailures).to.equal(
+      1
+    );
+    poller.disconnectedCallback();
+  });
+});

package/test/ia-book-actions.test.js

@@ -1,11 +1,14 @@
 import { html, fixture, expect, aTimeout } from '@open-wc/testing';
 import '@internetarchive/modal-manager';
-import '../src/ia-book-actions.js';
 import Sinon from 'sinon';
 
 import { SharedResizeObserver } from '@internetarchive/shared-resize-observer';
 import { LocalCache } from '@internetarchive/local-cache';
-import { unexpectedResponseError } from '../src/core/services/actions-handler/actions-handler-service.js';
+import { MAX_SILENT_TOKEN_REFRESH_FAILURES } from '../src/ia-book-actions.js';
+import {
+  unexpectedResponseError,
+  networkError,
+} from '../src/core/services/actions-handler/actions-handler-service.js';
 
 beforeEach(() => {
   const modalManager = document.createElement('modal-manager');
@@ -1734,93 +1737,157 @@ describe('Sentry reports (WEBDEV-9595)', () => {
   });
 });
 
-describe('handleLendingActionError - HTML 400 on create_token (WEBDEV-9595)', () => {
+describe('handleLendingActionError - routine create_token refresh failures (WEBDEV-9595)', () => {
   const htmlBadRequest = {
     success: false,
     error: unexpectedResponseError(400),
     status: 400,
     nonJsonResponse: true,
   };
+  // the service never answered: no modal on a routine refresh
+  const noAnswer = {
+    'an HTML 400 (WAF block)': htmlBadRequest,
+    'an HTML 502': {
+      ...htmlBadRequest,
+      error: unexpectedResponseError(502),
+      status: 502,
+    },
+    'a blocked or failed request': {
+      error: networkError,
+      detail: 'TypeError: Failed to fetch',
+      networkFailure: true,
+    },
+  };
+  // the service answered "no": the loan may really be gone
+  const serviceAnswer = {
+    success: false,
+    error: 'You do not currently have this book borrowed.',
+    status: 400,
+  };
   const liveLoan = {
     is_lendable: true,
     user_has_borrowed: true,
     browsingExpired: false,
     secondsLeftOnLoan: 300,
   };
-
-  it('shows no modal and keeps the session going on a routine refresh', async () => {
+  const setup = async () => {
     const el = await fixture(
       container({
         userid: '@user1',
-        identifier: 'html-400-routine',
+        identifier: 'token-refresh-failure',
         lendingStatus: liveLoan,
       })
     );
     await el.updateComplete;
-    const showErrorModalSpy = Sinon.spy(el, 'showErrorModal');
-    const clearAllSpy = Sinon.spy(window.IALendingIntervals, 'clearAll');
-    el.tokenPoller = { disconnectedCallback: Sinon.spy() };
+    return el;
+  };
+
+  for (const [name, data] of Object.entries(noAnswer)) {
+    it(`shows no modal and keeps the session going for ${name}`, async () => {
+      const el = await setup();
+      const showErrorModalSpy = Sinon.spy(el, 'showErrorModal');
+      const clearAllSpy = Sinon.spy(window.IALendingIntervals, 'clearAll');
+      el.tokenPoller = { disconnectedCallback: Sinon.spy() };
+
+      try {
+        el.handleLendingActionError({
+          detail: { action: 'create_token', isInitial: false, data },
+        });
+
+        expect(showErrorModalSpy.called).to.be.false;
+        // none of the create_token teardown ran
+        expect(clearAllSpy.called).to.be.false;
+        expect(el.tokenPoller.disconnectedCallback.called).to.be.false;
+        expect(el.lendingStatus.secondsLeftOnLoan).to.equal(300);
+        expect(el.lendingStatus.available_to_browse).to.be.undefined;
+      } finally {
+        clearAllSpy.restore();
+      }
+    });
+
+    it(`still shows the modal for ${name} when the book is first opening`, async () => {
+      const el = await setup();
+      const showErrorModalSpy = Sinon.spy(el, 'showErrorModal');
 
-    try {
       el.handleLendingActionError({
-        detail: { action: 'create_token', isInitial: false, data: htmlBadRequest },
+        detail: { action: 'create_token', isInitial: true, data },
       });
 
-      expect(showErrorModalSpy.called).to.be.false;
-      // none of the create_token teardown ran
-      expect(clearAllSpy.called).to.be.false;
-      expect(el.tokenPoller.disconnectedCallback.called).to.be.false;
-      expect(el.lendingStatus.secondsLeftOnLoan).to.equal(300);
-      expect(el.lendingStatus.available_to_browse).to.be.undefined;
-    } finally {
-      clearAllSpy.restore();
-    }
-  });
+      expect(showErrorModalSpy.calledOnce).to.be.true;
+    });
+  }
 
-  it('still shows the modal when the book is first opening', async () => {
-    const el = await fixture(
-      container({
-        userid: '@user1',
-        identifier: 'html-400-initial',
-        lendingStatus: liveLoan,
-      })
-    );
-    await el.updateComplete;
+  it("still shows the modal and resets the bar when the service itself says no", async () => {
+    const el = await setup();
     const showErrorModalSpy = Sinon.spy(el, 'showErrorModal');
 
     el.handleLendingActionError({
-      detail: { action: 'create_token', isInitial: true, data: htmlBadRequest },
+      detail: { action: 'create_token', isInitial: false, data: serviceAnswer },
     });
 
-    expect(showErrorModalSpy.calledOnce).to.be.true;
+    expect(
+      showErrorModalSpy.calledOnceWith(serviceAnswer.error, 'create_token')
+    ).to.be.true;
+    expect(el.lendingStatus.secondsLeftOnLoan).to.equal(0);
   });
+});
 
-  it("still shows the modal for the service's own JSON 400 and for an HTML 5xx", async () => {
+describe('handleLendingActionError - a run of unanswered token refreshes (WEBDEV-9595)', () => {
+  const blocked = {
+    error: networkError,
+    detail: 'TypeError: Failed to fetch',
+    networkFailure: true,
+  };
+  const setup = async () => {
     const el = await fixture(
       container({
         userid: '@user1',
-        identifier: 'html-400-other',
-        lendingStatus: liveLoan,
+        identifier: 'token-refresh-run',
+        lendingStatus: {
+          is_lendable: true,
+          user_has_borrowed: true,
+          browsingExpired: false,
+          secondsLeftOnLoan: 300,
+        },
       })
     );
     await el.updateComplete;
+    return el;
+  };
+
+  it(`stays silent for up to ${MAX_SILENT_TOKEN_REFRESH_FAILURES} failures in a row`, async () => {
+    const el = await setup();
+    const showErrorModalSpy = Sinon.spy(el, 'showErrorModal');
+
+    for (let n = 1; n <= MAX_SILENT_TOKEN_REFRESH_FAILURES; n += 1) {
+      el.handleLendingActionError({
+        detail: {
+          action: 'create_token',
+          isInitial: false,
+          consecutiveFailures: n,
+          data: blocked,
+        },
+      });
+    }
+
+    expect(showErrorModalSpy.called).to.be.false;
+  });
+
+  it('shows the modal and resets the bar on the next one, before the access token runs out', async () => {
+    const el = await setup();
     const showErrorModalSpy = Sinon.spy(el, 'showErrorModal');
 
     el.handleLendingActionError({
       detail: {
         action: 'create_token',
         isInitial: false,
-        data: { error: 'You do not currently have this book borrowed.' },
-      },
-    });
-    el.handleLendingActionError({
-      detail: {
-        action: 'create_token',
-        isInitial: false,
-        data: { ...htmlBadRequest, status: 502 },
+        consecutiveFailures: MAX_SILENT_TOKEN_REFRESH_FAILURES + 1,
+        data: blocked,
       },
     });
 
-    expect(showErrorModalSpy.calledTwice).to.be.true;
+    expect(showErrorModalSpy.calledOnceWith(networkError, 'create_token')).to
+      .be.true;
+    expect(el.lendingStatus.secondsLeftOnLoan).to.equal(0);
   });
 });