@internetarchive/ia-book-actions 1.4.6-alpha2 → 1.4.6-alpha4

package/package.json

@@ -7,7 +7,7 @@
   },
   "author": "Internet Archive",
   "license": "AGPL-3.0-only",
-  "version": "1.4.6-alpha2",
+  "version": "1.4.6-alpha4",
   "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
@@ -171,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,11 +1024,13 @@ export default class IABookActions extends LitElement {
       recoveringFromLoanExpiry: this.recoveringFromLoanExpiry,
     });
 
+    const consecutiveFailures = event?.detail?.consecutiveFailures ?? 1;
     if (
       action === 'create_token' &&
       !isInitial &&
       (eventData?.nonJsonResponse === true ||
-        eventData?.networkFailure === true)
+        eventData?.networkFailure === true) &&
+      consecutiveFailures <= MAX_SILENT_TOKEN_REFRESH_FAILURES
     ) {
       // The service never answered this routine refresh: something in
       // front of it did (the WAF's /about/400.html, an outage page), or the
@@ -1032,6 +1044,10 @@ export default class IABookActions extends LitElement {
       // 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 routine refresh got no answer from the service — no modal',
         {

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,

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,10 +1,10 @@
 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 { MAX_SILENT_TOKEN_REFRESH_FAILURES } from '../src/ia-book-actions.js';
 import {
   unexpectedResponseError,
   networkError,
@@ -1831,3 +1831,63 @@ describe('handleLendingActionError - routine create_token refresh failures (WEBD
     expect(el.lendingStatus.secondsLeftOnLoan).to.equal(0);
   });
 });
+
+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: '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,
+        consecutiveFailures: MAX_SILENT_TOKEN_REFRESH_FAILURES + 1,
+        data: blocked,
+      },
+    });
+
+    expect(showErrorModalSpy.calledOnceWith(networkError, 'create_token')).to
+      .be.true;
+    expect(el.lendingStatus.secondsLeftOnLoan).to.equal(0);
+  });
+});