tor-browser

test_merinoClient_sessions.js (11291B)

---

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

// Test for MerinoClient sessions.

"use strict";

const { MerinoClient } = ChromeUtils.importESModule(
 "moz-src:///browser/components/urlbar/MerinoClient.sys.mjs"
);

const { SEARCH_PARAMS } = MerinoClient;

let gClient;

add_setup(async () => {
 gClient = new MerinoClient();
 await MerinoTestUtils.server.start();
});

// In a single session, all requests should use the same session ID and the
// sequence number should be incremented.
add_task(async function singleSession() {
 for (let i = 0; i < 3; i++) {
   let query = "search" + i;
   await gClient.fetch({ query });

   MerinoTestUtils.server.checkAndClearRequests([
     {
       params: {
         [SEARCH_PARAMS.QUERY]: query,
         [SEARCH_PARAMS.SEQUENCE_NUMBER]: i,
       },
     },
   ]);
 }

 gClient.resetSession();
});

// Different sessions should use different session IDs and the sequence number
// should be reset.
add_task(async function manySessions() {
 for (let i = 0; i < 3; i++) {
   let query = "search" + i;
   await gClient.fetch({ query });

   MerinoTestUtils.server.checkAndClearRequests([
     {
       params: {
         [SEARCH_PARAMS.QUERY]: query,
         [SEARCH_PARAMS.SEQUENCE_NUMBER]: 0,
       },
     },
   ]);

   gClient.resetSession();
 }
});

// Tests two consecutive fetches:
//
// 1. Start a fetch
// 2. Wait for the mock Merino server to receive the request
// 3. Start a second fetch before the client receives the response
//
// The first fetch will be canceled by the second but the sequence number in the
// second fetch should still be incremented.
add_task(async function twoFetches_wait() {
 for (let i = 0; i < 3; i++) {
   // Send the first response after a delay to make sure the client will not
   // receive it before we start the second fetch.
   MerinoTestUtils.server.response.delay = UrlbarPrefs.get("merino.timeoutMs");

   // Start the first fetch but don't wait for it to finish.
   let requestPromise = MerinoTestUtils.server.waitForNextRequest();
   let query1 = "search" + i;
   gClient.fetch({ query: query1 });

   // Wait until the first request is received before starting the second
   // fetch, which will cancel the first. The response doesn't need to be
   // delayed, so remove it to make the test run faster.
   await requestPromise;
   delete MerinoTestUtils.server.response.delay;
   let query2 = query1 + "again";
   await gClient.fetch({ query: query2 });

   // The sequence number should have been incremented for each fetch.
   MerinoTestUtils.server.checkAndClearRequests([
     {
       params: {
         [SEARCH_PARAMS.QUERY]: query1,
         [SEARCH_PARAMS.SEQUENCE_NUMBER]: 2 * i,
       },
     },
     {
       params: {
         [SEARCH_PARAMS.QUERY]: query2,
         [SEARCH_PARAMS.SEQUENCE_NUMBER]: 2 * i + 1,
       },
     },
   ]);
 }

 gClient.resetSession();
});

// Tests two consecutive fetches:
//
// 1. Start a fetch
// 2. Immediately start a second fetch
//
// The first fetch will be canceled by the second but the sequence number in the
// second fetch should still be incremented.
add_task(async function twoFetches_immediate() {
 for (let i = 0; i < 3; i++) {
   // Send the first response after a delay to make sure the client will not
   // receive it before we start the second fetch.
   MerinoTestUtils.server.response.delay =
     100 * UrlbarPrefs.get("merino.timeoutMs");

   // Start the first fetch but don't wait for it to finish.
   let query1 = "search" + i;
   gClient.fetch({ query: query1 });

   // Immediately do a second fetch that cancels the first. The response
   // doesn't need to be delayed, so remove it to make the test run faster.
   delete MerinoTestUtils.server.response.delay;
   let query2 = query1 + "again";
   await gClient.fetch({ query: query2 });

   // The sequence number should have been incremented for each fetch, but the
   // first won't have reached the server since it was immediately canceled.
   MerinoTestUtils.server.checkAndClearRequests([
     {
       params: {
         [SEARCH_PARAMS.QUERY]: query2,
         [SEARCH_PARAMS.SEQUENCE_NUMBER]: 2 * i + 1,
       },
     },
   ]);
 }

 gClient.resetSession();
});

// When a network error occurs, the sequence number should still be incremented.
add_task(async function networkError() {
 for (let i = 0; i < 3; i++) {
   // Do a fetch that fails with a network error.
   let query1 = "search" + i;
   await MerinoTestUtils.server.withNetworkError(async () => {
     await gClient.fetch({ query: query1 });
   });

   Assert.equal(
     gClient.lastFetchStatus,
     "network_error",
     "The request failed with a network error"
   );

   // Do another fetch that successfully finishes.
   let query2 = query1 + "again";
   await gClient.fetch({ query: query2 });

   Assert.equal(
     gClient.lastFetchStatus,
     "success",
     "The request completed successfully"
   );

   // Only the second request should have been received but the sequence number
   // should have been incremented for each.
   MerinoTestUtils.server.checkAndClearRequests([
     {
       params: {
         [SEARCH_PARAMS.QUERY]: query2,
         [SEARCH_PARAMS.SEQUENCE_NUMBER]: 2 * i + 1,
       },
     },
   ]);
 }

 gClient.resetSession();
});

// When the server returns a response with an HTTP error, the sequence number
// should be incremented.
add_task(async function httpError() {
 for (let i = 0; i < 3; i++) {
   // Do a fetch that fails with an HTTP error.
   MerinoTestUtils.server.response.status = 500;
   let query1 = "search" + i;
   await gClient.fetch({ query: query1 });

   Assert.equal(
     gClient.lastFetchStatus,
     "http_error",
     "The last request failed with a network error"
   );

   // Do another fetch that successfully finishes.
   MerinoTestUtils.server.response.status = 200;
   let query2 = query1 + "again";
   await gClient.fetch({ query: query2 });

   Assert.equal(
     gClient.lastFetchStatus,
     "success",
     "The last request completed successfully"
   );

   // Both requests should have been received and the sequence number should
   // have been incremented for each.
   MerinoTestUtils.server.checkAndClearRequests([
     {
       params: {
         [SEARCH_PARAMS.QUERY]: query1,
         [SEARCH_PARAMS.SEQUENCE_NUMBER]: 2 * i,
       },
     },
     {
       params: {
         [SEARCH_PARAMS.QUERY]: query2,
         [SEARCH_PARAMS.SEQUENCE_NUMBER]: 2 * i + 1,
       },
     },
   ]);

   MerinoTestUtils.server.reset();
 }

 gClient.resetSession();
});

// When the client times out waiting for a response but later receives it and no
// other fetch happens in the meantime, the sequence number should be
// incremented.
add_task(async function clientTimeout_wait() {
 for (let i = 0; i < 3; i++) {
   // Do a fetch that causes the client to time out.
   MerinoTestUtils.server.response.delay =
     2 * UrlbarPrefs.get("merino.timeoutMs");
   let responsePromise = gClient.waitForNextResponse();
   let query1 = "search" + i;
   await gClient.fetch({ query: query1 });

   Assert.equal(
     gClient.lastFetchStatus,
     "timeout",
     "The last request failed with a client timeout"
   );

   // Wait for the client to receive the response.
   await responsePromise;

   // Do another fetch that successfully finishes.
   delete MerinoTestUtils.server.response.delay;
   let query2 = query1 + "again";
   await gClient.fetch({ query: query2 });

   Assert.equal(
     gClient.lastFetchStatus,
     "success",
     "The last request completed successfully"
   );

   MerinoTestUtils.server.checkAndClearRequests([
     {
       params: {
         [SEARCH_PARAMS.QUERY]: query1,
         [SEARCH_PARAMS.SEQUENCE_NUMBER]: 2 * i,
       },
     },
     {
       params: {
         [SEARCH_PARAMS.QUERY]: query2,
         [SEARCH_PARAMS.SEQUENCE_NUMBER]: 2 * i + 1,
       },
     },
   ]);
 }

 gClient.resetSession();
});

// When the client times out waiting for a response and a second fetch starts
// before the response is received, the first fetch should be canceled but the
// sequence number should still be incremented.
add_task(async function clientTimeout_canceled() {
 for (let i = 0; i < 3; i++) {
   // Do a fetch that causes the client to time out.
   MerinoTestUtils.server.response.delay =
     2 * UrlbarPrefs.get("merino.timeoutMs");
   let query1 = "search" + i;
   await gClient.fetch({ query: query1 });

   Assert.equal(
     gClient.lastFetchStatus,
     "timeout",
     "The last request failed with a client timeout"
   );

   // Do another fetch that successfully finishes.
   delete MerinoTestUtils.server.response.delay;
   let query2 = query1 + "again";
   await gClient.fetch({ query: query2 });

   Assert.equal(
     gClient.lastFetchStatus,
     "success",
     "The last request completed successfully"
   );

   MerinoTestUtils.server.checkAndClearRequests([
     {
       params: {
         [SEARCH_PARAMS.QUERY]: query1,
         [SEARCH_PARAMS.SEQUENCE_NUMBER]: 2 * i,
       },
     },
     {
       params: {
         [SEARCH_PARAMS.QUERY]: query2,
         [SEARCH_PARAMS.SEQUENCE_NUMBER]: 2 * i + 1,
       },
     },
   ]);
 }

 gClient.resetSession();
});

// When the session times out, the next fetch should use a new session ID and
// the sequence number should be reset.
add_task(async function sessionTimeout() {
 // Set the session timeout to something reasonable to test.
 let originalTimeoutMs = gClient.sessionTimeoutMs;
 gClient.sessionTimeoutMs = 500;

 // Do a fetch.
 let query1 = "search";
 await gClient.fetch({ query: query1 });

 // Wait for the session to time out.
 await gClient.waitForNextSessionReset();

 Assert.strictEqual(
   gClient.sessionID,
   null,
   "sessionID is null after session timeout"
 );
 Assert.strictEqual(
   gClient.sequenceNumber,
   0,
   "sequenceNumber is zero after session timeout"
 );
 Assert.strictEqual(
   gClient._test_sessionTimer,
   null,
   "sessionTimer is null after session timeout"
 );

 // Do another fetch.
 let query2 = query1 + "again";
 await gClient.fetch({ query: query2 });

 // The second request's sequence number should be zero due to the session
 // timeout.
 MerinoTestUtils.server.checkAndClearRequests([
   {
     params: {
       [SEARCH_PARAMS.QUERY]: query1,
       [SEARCH_PARAMS.SEQUENCE_NUMBER]: 0,
     },
   },
   {
     params: {
       [SEARCH_PARAMS.QUERY]: query2,
       [SEARCH_PARAMS.SEQUENCE_NUMBER]: 0,
     },
   },
 ]);

 Assert.ok(
   gClient.sessionID,
   "sessionID is non-null after first request in a new session"
 );
 Assert.equal(
   gClient.sequenceNumber,
   1,
   "sequenceNumber is one after first request in a new session"
 );
 Assert.ok(
   gClient._test_sessionTimer,
   "sessionTimer is non-null after first request in a new session"
 );

 gClient.sessionTimeoutMs = originalTimeoutMs;
 gClient.resetSession();
});