lighthouse 12.1.0-dev.20240630 → 12.1.0-dev.20240702

package/core/lib/lantern/simulation/ConnectionPool.js

@@ -1,152 +0,0 @@
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from '../lantern.js';
-import {NetworkAnalyzer} from './NetworkAnalyzer.js';
-import {TcpConnection} from './TcpConnection.js';
-
-const DEFAULT_SERVER_RESPONSE_TIME = 30;
-const TLS_SCHEMES = ['https', 'wss'];
-
-// Each origin can have 6 simulatenous connections open
-// https://cs.chromium.org/chromium/src/net/socket/client_socket_pool_manager.cc?type=cs&q="int+g_max_sockets_per_group"
-const CONNECTIONS_PER_ORIGIN = 6;
-
-export class ConnectionPool {
-  /**
-   * @param {Lantern.NetworkRequest[]} records
-   * @param {Required<Lantern.Simulation.Options>} options
-   */
-  constructor(records, options) {
-    this._options = options;
-
-    this._records = records;
-    /** @type {Map<string, TcpConnection[]>} */
-    this._connectionsByOrigin = new Map();
-    /** @type {Map<Lantern.NetworkRequest, TcpConnection>} */
-    this._connectionsByRequest = new Map();
-    this._connectionsInUse = new Set();
-    this._connectionReusedByRequestId = NetworkAnalyzer.estimateIfConnectionWasReused(records, {
-      forceCoarseEstimates: true,
-    });
-
-    this._initializeConnections();
-  }
-
-  /**
-   * @return {TcpConnection[]}
-   */
-  connectionsInUse() {
-    return Array.from(this._connectionsInUse);
-  }
-
-  _initializeConnections() {
-    const connectionReused = this._connectionReusedByRequestId;
-    const additionalRttByOrigin = this._options.additionalRttByOrigin;
-    const serverResponseTimeByOrigin = this._options.serverResponseTimeByOrigin;
-
-    const recordsByOrigin = NetworkAnalyzer.groupByOrigin(this._records);
-    for (const [origin, requests] of recordsByOrigin.entries()) {
-      const connections = [];
-      const additionalRtt = additionalRttByOrigin.get(origin) || 0;
-      const responseTime = serverResponseTimeByOrigin.get(origin) || DEFAULT_SERVER_RESPONSE_TIME;
-
-      for (const request of requests) {
-        if (connectionReused.get(request.requestId)) continue;
-
-        const isTLS = TLS_SCHEMES.includes(request.parsedURL.scheme);
-        const isH2 = request.protocol === 'h2';
-        const connection = new TcpConnection(
-          this._options.rtt + additionalRtt,
-          this._options.throughput,
-          responseTime,
-          isTLS,
-          isH2
-        );
-
-        connections.push(connection);
-      }
-
-      if (!connections.length) {
-        throw new Error(`Could not find a connection for origin: ${origin}`);
-      }
-
-      // Make sure each origin has minimum number of connections available for max throughput.
-      // But only if it's not over H2 which maximizes throughput already.
-      const minConnections = connections[0].isH2() ? 1 : CONNECTIONS_PER_ORIGIN;
-      while (connections.length < minConnections) connections.push(connections[0].clone());
-
-      this._connectionsByOrigin.set(origin, connections);
-    }
-  }
-
-  /**
-   * @param {Array<TcpConnection>} connections
-   */
-  _findAvailableConnectionWithLargestCongestionWindow(connections) {
-    /** @type {TcpConnection|null} */
-    let maxConnection = null;
-    for (let i = 0; i < connections.length; i++) {
-      const connection = connections[i];
-
-      // Connections that are in use are never available.
-      if (this._connectionsInUse.has(connection)) {
-        continue;
-      }
-
-      // This connection is a match and is available! Update our max if it has a larger congestionWindow
-      const currentMax = (maxConnection?.congestionWindow) || -Infinity;
-      if (connection.congestionWindow > currentMax) maxConnection = connection;
-    }
-
-    return maxConnection;
-  }
-
-  /**
-   * This method finds an available connection to the origin specified by the network request or null
-   * if no connection was available. If returned, connection will not be available for other network
-   * records until release is called.
-   *
-   * @param {Lantern.NetworkRequest} request
-   * @return {?TcpConnection}
-   */
-  acquire(request) {
-    if (this._connectionsByRequest.has(request)) throw new Error('Record already has a connection');
-
-    const origin = request.parsedURL.securityOrigin;
-    const connections = this._connectionsByOrigin.get(origin) || [];
-    const connectionToUse = this._findAvailableConnectionWithLargestCongestionWindow(connections);
-
-    if (!connectionToUse) return null;
-
-    this._connectionsInUse.add(connectionToUse);
-    this._connectionsByRequest.set(request, connectionToUse);
-    return connectionToUse;
-  }
-
-  /**
-   * Return the connection currently being used to fetch a request. If no connection
-   * currently being used for this request, an error will be thrown.
-   *
-   * @param {Lantern.NetworkRequest} request
-   * @return {TcpConnection}
-   */
-  acquireActiveConnectionFromRequest(request) {
-    const activeConnection = this._connectionsByRequest.get(request);
-    if (!activeConnection) throw new Error('Could not find an active connection for request');
-
-    return activeConnection;
-  }
-
-  /**
-   * @param {Lantern.NetworkRequest} request
-   */
-  release(request) {
-    const connection = this._connectionsByRequest.get(request);
-    this._connectionsByRequest.delete(request);
-    this._connectionsInUse.delete(connection);
-  }
-}

package/core/lib/lantern/simulation/ConnectionPool.test.js

@@ -1,195 +0,0 @@
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import assert from 'assert/strict';
-import {URL} from 'url';
-
-import * as Lantern from '../lantern.js';
-
-const {ConnectionPool} = Lantern.Simulation;
-
-describe('ConnectionPool', () => {
-  const rtt = 100;
-  const throughput = 10000 * 1024;
-  let requestId;
-
-  function request(data = {}) {
-    const url = data.url || 'http://example.com';
-    const origin = new URL(url).origin;
-    const scheme = url.split(':')[0];
-
-    return Object.assign({
-      requestId: requestId++,
-      url,
-      protocol: 'http/1.1',
-      parsedURL: {scheme, securityOrigin: origin},
-    }, data);
-  }
-
-  function simulationOptions(options) {
-    return Object.assign(
-      {
-        rtt: 150,
-        throughput: 1024,
-        additionalRttByOrigin: new Map(),
-        serverResponseTimeByOrigin: new Map(),
-      },
-      options
-    );
-  }
-
-  beforeEach(() => {
-    requestId = 1;
-  });
-
-  describe('#constructor', () => {
-    it('should create the pool', () => {
-      const pool = new ConnectionPool([request()], simulationOptions({rtt, throughput}));
-      // Make sure 6 connections are created for each origin
-      assert.equal(pool._connectionsByOrigin.get('http://example.com').length, 6);
-      // Make sure it populates connectionWasReused
-      assert.equal(pool._connectionReusedByRequestId.get(1), false);
-
-      const connection = pool._connectionsByOrigin.get('http://example.com')[0];
-      assert.equal(connection._rtt, rtt);
-      assert.equal(connection._throughput, throughput);
-      assert.equal(connection._serverLatency, 30); // sets to default value
-    });
-
-    it('should set TLS properly', () => {
-      const recordA = request({url: 'https://example.com'});
-      const pool = new ConnectionPool([recordA], simulationOptions({rtt, throughput}));
-      const connection = pool._connectionsByOrigin.get('https://example.com')[0];
-      assert.ok(connection._ssl, 'should have set connection TLS');
-    });
-
-    it('should set H2 properly', () => {
-      const recordA = request({protocol: 'h2'});
-      const pool = new ConnectionPool([recordA], simulationOptions({rtt, throughput}));
-      const connection = pool._connectionsByOrigin.get('http://example.com')[0];
-      assert.ok(connection.isH2(), 'should have set HTTP/2');
-      assert.equal(pool._connectionsByOrigin.get('http://example.com').length, 1);
-    });
-
-    it('should set origin-specific RTT properly', () => {
-      const additionalRttByOrigin = new Map([['http://example.com', 63]]);
-      const pool = new ConnectionPool([request()],
-          simulationOptions({rtt, throughput, additionalRttByOrigin}));
-      const connection = pool._connectionsByOrigin.get('http://example.com')[0];
-      assert.ok(connection._rtt, rtt + 63);
-    });
-
-    it('should set origin-specific server latency properly', () => {
-      const serverResponseTimeByOrigin = new Map([['http://example.com', 63]]);
-      const pool = new ConnectionPool([request()],
-          simulationOptions({rtt, throughput, serverResponseTimeByOrigin}));
-      const connection = pool._connectionsByOrigin.get('http://example.com')[0];
-      assert.ok(connection._serverLatency, 63);
-    });
-  });
-
-  describe('.acquire', () => {
-    it('should remember the connection associated with each request', () => {
-      const requestA = request();
-      const requestB = request();
-      const pool = new ConnectionPool([requestA, requestB], simulationOptions({rtt, throughput}));
-
-      const connectionForA = pool.acquire(requestA);
-      const connectionForB = pool.acquire(requestB);
-      for (let i = 0; i < 10; i++) {
-        assert.equal(pool.acquireActiveConnectionFromRequest(requestA), connectionForA);
-        assert.equal(pool.acquireActiveConnectionFromRequest(requestB), connectionForB);
-      }
-
-      assert.deepStrictEqual(pool.connectionsInUse(), [connectionForA, connectionForB]);
-    });
-
-    it('should allocate at least 6 connections', () => {
-      const pool = new ConnectionPool([request()], simulationOptions({rtt, throughput}));
-      for (let i = 0; i < 6; i++) {
-        assert.ok(pool.acquire(request()), `did not find connection for ${i}th request`);
-      }
-    });
-
-    it('should allocate all connections', () => {
-      const records = new Array(7).fill(undefined, 0, 7).map(() => request());
-      const pool = new ConnectionPool(records, simulationOptions({rtt, throughput}));
-      const connections = records.map(request => pool.acquire(request));
-      assert.ok(connections[0], 'did not find connection for 1st request');
-      assert.ok(connections[5], 'did not find connection for 6th request');
-      assert.ok(connections[6], 'did not find connection for 7th request');
-    });
-
-    it('should be oblivious to connection reuse', () => {
-      const coldRecord = request();
-      const warmRecord = request();
-      const pool = new ConnectionPool([coldRecord, warmRecord],
-          simulationOptions({rtt, throughput}));
-      pool._connectionReusedByRequestId.set(warmRecord.requestId, true);
-
-      assert.ok(pool.acquire(coldRecord), 'should have acquired connection');
-      assert.ok(pool.acquire(warmRecord), 'should have acquired connection');
-      pool.release(coldRecord);
-
-      for (const connection of pool._connectionsByOrigin.get('http://example.com')) {
-        connection.setWarmed(true);
-      }
-
-      assert.ok(pool.acquire(coldRecord), 'should have acquired connection');
-      assert.ok(pool.acquireActiveConnectionFromRequest(warmRecord),
-        'should have acquired connection');
-    });
-
-    it('should acquire in order of warmness', () => {
-      const recordA = request();
-      const recordB = request();
-      const recordC = request();
-      const pool = new ConnectionPool([recordA, recordB, recordC],
-          simulationOptions({rtt, throughput}));
-      pool._connectionReusedByRequestId.set(recordA.requestId, true);
-      pool._connectionReusedByRequestId.set(recordB.requestId, true);
-      pool._connectionReusedByRequestId.set(recordC.requestId, true);
-
-      const [connectionWarm, connectionWarmer, connectionWarmest] =
-        pool._connectionsByOrigin.get('http://example.com');
-      connectionWarm.setWarmed(true);
-      connectionWarm.setCongestionWindow(10);
-      connectionWarmer.setWarmed(true);
-      connectionWarmer.setCongestionWindow(100);
-      connectionWarmest.setWarmed(true);
-      connectionWarmest.setCongestionWindow(1000);
-
-      assert.equal(pool.acquire(recordA), connectionWarmest);
-      assert.equal(pool.acquire(recordB), connectionWarmer);
-      assert.equal(pool.acquire(recordC), connectionWarm);
-    });
-  });
-
-  describe('.release', () => {
-    it('noop for request without connection', () => {
-      const requestA = request();
-      const pool = new ConnectionPool([requestA], simulationOptions({rtt, throughput}));
-      assert.equal(pool.release(requestA), undefined);
-    });
-
-    it('frees the connection for reissue', () => {
-      const requests = new Array(6).fill(undefined, 0, 7).map(() => request());
-      const pool = new ConnectionPool(requests, simulationOptions({rtt, throughput}));
-      requests.push(request());
-
-      requests.forEach(request => pool.acquire(request));
-
-      assert.equal(pool.connectionsInUse().length, 6);
-      assert.ok(!pool.acquire(requests[6]), 'had connection that is in use');
-
-      pool.release(requests[0]);
-      assert.equal(pool.connectionsInUse().length, 5);
-
-      assert.ok(pool.acquire(requests[6]), 'could not reissue released connection');
-      assert.ok(!pool.acquire(requests[0]), 'had connection that is in use');
-    });
-  });
-});

package/core/lib/lantern/simulation/Constants.d.ts

@@ -1,52 +0,0 @@
-export namespace Constants {
-    export { throttling };
-}
-declare namespace throttling {
-    export { DEVTOOLS_RTT_ADJUSTMENT_FACTOR };
-    export { DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR };
-    export namespace mobileSlow4G {
-        const rttMs: number;
-        const throughputKbps: number;
-        const requestLatencyMs: number;
-        const downloadThroughputKbps: number;
-        const uploadThroughputKbps: number;
-        const cpuSlowdownMultiplier: number;
-    }
-    export namespace mobileRegular3G {
-        const rttMs_1: number;
-        export { rttMs_1 as rttMs };
-        const throughputKbps_1: number;
-        export { throughputKbps_1 as throughputKbps };
-        const requestLatencyMs_1: number;
-        export { requestLatencyMs_1 as requestLatencyMs };
-        const downloadThroughputKbps_1: number;
-        export { downloadThroughputKbps_1 as downloadThroughputKbps };
-        const uploadThroughputKbps_1: number;
-        export { uploadThroughputKbps_1 as uploadThroughputKbps };
-        const cpuSlowdownMultiplier_1: number;
-        export { cpuSlowdownMultiplier_1 as cpuSlowdownMultiplier };
-    }
-    export namespace desktopDense4G {
-        const rttMs_2: number;
-        export { rttMs_2 as rttMs };
-        const throughputKbps_2: number;
-        export { throughputKbps_2 as throughputKbps };
-        const cpuSlowdownMultiplier_2: number;
-        export { cpuSlowdownMultiplier_2 as cpuSlowdownMultiplier };
-        const requestLatencyMs_2: number;
-        export { requestLatencyMs_2 as requestLatencyMs };
-        const downloadThroughputKbps_2: number;
-        export { downloadThroughputKbps_2 as downloadThroughputKbps };
-        const uploadThroughputKbps_2: number;
-        export { uploadThroughputKbps_2 as uploadThroughputKbps };
-    }
-}
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-declare const DEVTOOLS_RTT_ADJUSTMENT_FACTOR: 3.75;
-declare const DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR: 0.9;
-export {};
-//# sourceMappingURL=Constants.d.ts.map

package/core/lib/lantern/simulation/Constants.js

@@ -1,48 +0,0 @@
-/**
- * @license
- * Copyright 2024 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-const DEVTOOLS_RTT_ADJUSTMENT_FACTOR = 3.75;
-const DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR = 0.9;
-
-const throttling = {
-  DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
-  DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-  // These values align with WebPageTest's definition of "Fast 3G"
-  // But offer similar characteristics to roughly the 75th percentile of 4G connections.
-  mobileSlow4G: {
-    rttMs: 150,
-    throughputKbps: 1.6 * 1024,
-    requestLatencyMs: 150 * DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
-    downloadThroughputKbps: 1.6 * 1024 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-    uploadThroughputKbps: 750 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-    cpuSlowdownMultiplier: 4,
-  },
-  // These values partially align with WebPageTest's definition of "Regular 3G".
-  // These values are meant to roughly align with Chrome UX report's 3G definition which are based
-  // on HTTP RTT of 300-1400ms and downlink throughput of <700kbps.
-  mobileRegular3G: {
-    rttMs: 300,
-    throughputKbps: 700,
-    requestLatencyMs: 300 * DEVTOOLS_RTT_ADJUSTMENT_FACTOR,
-    downloadThroughputKbps: 700 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-    uploadThroughputKbps: 700 * DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR,
-    cpuSlowdownMultiplier: 4,
-  },
-  // Using a "broadband" connection type
-  // Corresponds to "Dense 4G 25th percentile" in https://docs.google.com/document/d/1Ft1Bnq9-t4jK5egLSOc28IL4TvR-Tt0se_1faTA4KTY/edit#heading=h.bb7nfy2x9e5v
-  desktopDense4G: {
-    rttMs: 40,
-    throughputKbps: 10 * 1024,
-    cpuSlowdownMultiplier: 1,
-    requestLatencyMs: 0, // 0 means unset
-    downloadThroughputKbps: 0,
-    uploadThroughputKbps: 0,
-  },
-};
-
-const Constants = {throttling};
-
-export {Constants};

package/core/lib/lantern/simulation/DNSCache.d.ts

@@ -1,42 +0,0 @@
-export class DNSCache {
-    /**
-     * @param {{rtt: number}} options
-     */
-    constructor({ rtt }: {
-        rtt: number;
-    });
-    _rtt: number;
-    /** @type {Map<string, {resolvedAt: number}>} */
-    _resolvedDomainNames: Map<string, {
-        resolvedAt: number;
-    }>;
-    /**
-     * @param {Lantern.NetworkRequest} request
-     * @param {{requestedAt: number, shouldUpdateCache: boolean}=} options
-     * @return {number}
-     */
-    getTimeUntilResolution(request: Lantern.NetworkRequest, options?: {
-        requestedAt: number;
-        shouldUpdateCache: boolean;
-    } | undefined): number;
-    /**
-     * @param {Lantern.NetworkRequest} request
-     * @param {number} resolvedAt
-     */
-    _updateCacheResolvedAtIfNeeded(request: Lantern.NetworkRequest, resolvedAt: number): void;
-    /**
-     * Forcefully sets the DNS resolution time for a request.
-     * Useful for testing and alternate execution simulations.
-     *
-     * @param {string} domain
-     * @param {number} resolvedAt
-     */
-    setResolvedAt(domain: string, resolvedAt: number): void;
-}
-export namespace DNSCache {
-    export { DNS_RESOLUTION_RTT_MULTIPLIER as RTT_MULTIPLIER };
-}
-import * as Lantern from '../lantern.js';
-declare const DNS_RESOLUTION_RTT_MULTIPLIER: 2;
-export {};
-//# sourceMappingURL=DNSCache.d.ts.map

package/core/lib/lantern/simulation/DNSCache.js

@@ -1,74 +0,0 @@
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from '../lantern.js';
-
-// A DNS lookup will usually take ~1-2 roundtrips of connection latency plus the extra DNS routing time.
-// Example: https://www.webpagetest.org/result/180703_3A_e33ec79747c002ed4d7bcbfc81462203/1/details/#waterfall_view_step1
-// Example: https://www.webpagetest.org/result/180707_1M_89673eb633b5d98386de95dfcf9b33d5/1/details/#waterfall_view_step1
-// DNS is highly variable though, many times it's a little more than 1, but can easily be 4-5x RTT.
-// We'll use 2 since it seems to give the most accurate results on average, but this can be tweaked.
-const DNS_RESOLUTION_RTT_MULTIPLIER = 2;
-
-class DNSCache {
-  /**
-   * @param {{rtt: number}} options
-   */
-  constructor({rtt}) {
-    this._rtt = rtt;
-
-    /** @type {Map<string, {resolvedAt: number}>} */
-    this._resolvedDomainNames = new Map();
-  }
-
-  /**
-   * @param {Lantern.NetworkRequest} request
-   * @param {{requestedAt: number, shouldUpdateCache: boolean}=} options
-   * @return {number}
-   */
-  getTimeUntilResolution(request, options) {
-    const {requestedAt = 0, shouldUpdateCache = false} = options || {};
-
-    const domain = request.parsedURL.host;
-    const cacheEntry = this._resolvedDomainNames.get(domain);
-    let timeUntilResolved = this._rtt * DNSCache.RTT_MULTIPLIER;
-    if (cacheEntry) {
-      const timeUntilCachedIsResolved = Math.max(cacheEntry.resolvedAt - requestedAt, 0);
-      timeUntilResolved = Math.min(timeUntilCachedIsResolved, timeUntilResolved);
-    }
-
-    const resolvedAt = requestedAt + timeUntilResolved;
-    if (shouldUpdateCache) this._updateCacheResolvedAtIfNeeded(request, resolvedAt);
-
-    return timeUntilResolved;
-  }
-
-  /**
-   * @param {Lantern.NetworkRequest} request
-   * @param {number} resolvedAt
-   */
-  _updateCacheResolvedAtIfNeeded(request, resolvedAt) {
-    const domain = request.parsedURL.host;
-    const cacheEntry = this._resolvedDomainNames.get(domain) || {resolvedAt};
-    cacheEntry.resolvedAt = Math.min(cacheEntry.resolvedAt, resolvedAt);
-    this._resolvedDomainNames.set(domain, cacheEntry);
-  }
-
-  /**
-   * Forcefully sets the DNS resolution time for a request.
-   * Useful for testing and alternate execution simulations.
-   *
-   * @param {string} domain
-   * @param {number} resolvedAt
-   */
-  setResolvedAt(domain, resolvedAt) {
-    this._resolvedDomainNames.set(domain, {resolvedAt});
-  }
-}
-
-DNSCache.RTT_MULTIPLIER = DNS_RESOLUTION_RTT_MULTIPLIER;
-
-export {DNSCache};

package/core/lib/lantern/simulation/DNSCache.test.js

@@ -1,72 +0,0 @@
-/**
- * @license
- * Copyright 2018 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-
-import * as Lantern from '../lantern.js';
-
-const {DNSCache} = Lantern.Simulation;
-
-const MULTIPLIER = DNSCache.RTT_MULTIPLIER;
-
-describe('DNSCache', () => {
-  let dns;
-  let request;
-
-  beforeEach(() => {
-    dns = new DNSCache({rtt: 100});
-    request = {parsedURL: {host: 'example.com'}};
-  });
-
-  describe('.getTimeUntilResolution', () => {
-    it('should return the RTT multiplied', () => {
-      const resolutionTime = dns.getTimeUntilResolution(request);
-      expect(resolutionTime).toBe(100 * MULTIPLIER);
-    });
-
-    it('should return time with requestedAt', () => {
-      const resolutionTime = dns.getTimeUntilResolution(request, {requestedAt: 1500});
-      expect(resolutionTime).toBe(100 * MULTIPLIER);
-    });
-
-    it('should not cache by default', () => {
-      dns.getTimeUntilResolution(request, {requestedAt: 0});
-      const resolutionTime = dns.getTimeUntilResolution(request, {requestedAt: 1000});
-      expect(resolutionTime).toBe(100 * MULTIPLIER);
-    });
-
-    it('should cache when told', () => {
-      dns.getTimeUntilResolution(request, {requestedAt: 0, shouldUpdateCache: true});
-      const resolutionTime = dns.getTimeUntilResolution(request, {requestedAt: 1000});
-      expect(resolutionTime).toBe(0);
-    });
-
-    it('should cache by domain', () => {
-      dns.getTimeUntilResolution(request, {requestedAt: 0, shouldUpdateCache: true});
-      const otherRequest = {parsedURL: {host: 'other-example.com'}};
-      const resolutionTime = dns.getTimeUntilResolution(otherRequest, {requestedAt: 1000});
-      expect(resolutionTime).toBe(100 * MULTIPLIER);
-    });
-
-    it('should not update cache with later times', () => {
-      dns.getTimeUntilResolution(request, {requestedAt: 1000, shouldUpdateCache: true});
-      dns.getTimeUntilResolution(request, {requestedAt: 1500, shouldUpdateCache: true});
-      dns.getTimeUntilResolution(request, {requestedAt: 500, shouldUpdateCache: true});
-      dns.getTimeUntilResolution(request, {requestedAt: 5000, shouldUpdateCache: true});
-
-      expect(dns.getTimeUntilResolution(request, {requestedAt: 0})).toBe(100 * MULTIPLIER);
-      expect(dns.getTimeUntilResolution(request, {requestedAt: 550})).toBe(100 * MULTIPLIER - 50);
-      expect(dns.getTimeUntilResolution(request, {requestedAt: 1000})).toBe(0);
-      expect(dns.getTimeUntilResolution(request, {requestedAt: 2000})).toBe(0);
-    });
-  });
-
-  describe('.setResolvedAt', () => {
-    it('should set the DNS resolution time for a request', () => {
-      dns.setResolvedAt(request.parsedURL.host, 123);
-      const resolutionTime = dns.getTimeUntilResolution(request);
-      expect(resolutionTime).toEqual(123);
-    });
-  });
-});