lighthouse 12.0.0-dev.20240611 → 12.0.0-dev.20240613

package/core/lib/lantern/{simulator/simulator.js → simulation/Simulator.js}

@@ -4,21 +4,20 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 
-import * as Lantern from '../types/lantern.js';
-import {BaseNode} from '../base-node.js';
-import {TcpConnection} from './tcp-connection.js';
-import {ConnectionPool} from './connection-pool.js';
-import {DNSCache} from './dns-cache.js';
-import {SimulatorTimingMap} from './simulator-timing-map.js';
-import {constants} from '../lantern.js';
-
-const defaultThrottling = constants.throttling.mobileSlow4G;
-
-/** @typedef {import('../base-node.js').Node} Node */
-/** @typedef {import('../network-node.js').NetworkNode} NetworkNode */
-/** @typedef {import('../cpu-node.js').CPUNode} CpuNode */
-/** @typedef {import('./simulator-timing-map.js').CpuNodeTimingComplete | import('./simulator-timing-map.js').NetworkNodeTimingComplete} CompleteNodeTiming */
-/** @typedef {import('./simulator-timing-map.js').ConnectionTiming} ConnectionTiming */
+import * as Lantern from '../lantern.js';
+import {TcpConnection} from './TcpConnection.js';
+import {ConnectionPool} from './ConnectionPool.js';
+import {DNSCache} from './DNSCache.js';
+import {SimulatorTimingMap} from './SimulationTimingMap.js';
+
+const Constants = Lantern.Simulation.Constants;
+const defaultThrottling = Constants.throttling.mobileSlow4G;
+
+/** @typedef {import('../BaseNode.js').Node} Node */
+/** @typedef {import('../NetworkNode.js').NetworkNode} NetworkNode */
+/** @typedef {import('../CpuNode.js').CPUNode} CpuNode */
+/** @typedef {import('./SimulationTimingMap.js').CpuNodeTimingComplete | import('./SimulationTimingMap.js').NetworkNodeTimingComplete} CompleteNodeTiming */
+/** @typedef {import('./SimulationTimingMap.js').ConnectionTiming} ConnectionTiming */
 
 // see https://cs.chromium.org/search/?q=kDefaultMaxNumDelayableRequestsPerClient&sq=package:chromium&type=cs
 const DEFAULT_MAXIMUM_CONCURRENT_REQUESTS = 10;
@@ -82,10 +81,10 @@ class Simulator {
       case 'devtools':
         if (throttling) {
           options.rtt =
-            throttling.requestLatencyMs / constants.throttling.DEVTOOLS_RTT_ADJUSTMENT_FACTOR;
+            throttling.requestLatencyMs / Constants.throttling.DEVTOOLS_RTT_ADJUSTMENT_FACTOR;
           options.throughput =
             throttling.downloadThroughputKbps * 1024 /
-            constants.throttling.DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR;
+            Constants.throttling.DEVTOOLS_THROUGHPUT_ADJUSTMENT_FACTOR;
         }
 
         options.cpuSlowdownMultiplier = 1;
@@ -162,7 +161,7 @@ class Simulator {
     /** @type {Lantern.NetworkRequest[]} */
     const records = [];
     graph.getRootNode().traverse(node => {
-      if (node.type === BaseNode.TYPES.NETWORK) {
+      if (node.type === Lantern.BaseNode.TYPES.NETWORK) {
         records.push(node.request);
       }
     });
@@ -268,7 +267,7 @@ class Simulator {
    * @param {number} totalElapsedTime
    */
   _startNodeIfPossible(node, totalElapsedTime) {
-    if (node.type === BaseNode.TYPES.CPU) {
+    if (node.type === Lantern.BaseNode.TYPES.CPU) {
       // Start a CPU task if there's no other CPU task in process
       if (this._numberInProgress(node.type) === 0) {
         this._markNodeAsInProgress(node, totalElapsedTime);
@@ -277,7 +276,7 @@ class Simulator {
       return;
     }
 
-    if (node.type !== BaseNode.TYPES.NETWORK) throw new Error('Unsupported');
+    if (node.type !== Lantern.BaseNode.TYPES.NETWORK) throw new Error('Unsupported');
 
     // If a network request is connectionless, we can always start it, so skip the connection checks
     if (!node.isConnectionless) {
@@ -296,7 +295,7 @@ class Simulator {
    * currently in flight.
    */
   _updateNetworkCapacity() {
-    const inFlight = this._numberInProgress(BaseNode.TYPES.NETWORK);
+    const inFlight = this._numberInProgress(Lantern.BaseNode.TYPES.NETWORK);
     if (inFlight === 0) return;
 
     for (const connection of this._connectionPool.connectionsInUse()) {
@@ -310,9 +309,9 @@ class Simulator {
    * @return {number}
    */
   _estimateTimeRemaining(node) {
-    if (node.type === BaseNode.TYPES.CPU) {
+    if (node.type === Lantern.BaseNode.TYPES.CPU) {
       return this._estimateCPUTimeRemaining(node);
-    } else if (node.type === BaseNode.TYPES.NETWORK) {
+    } else if (node.type === Lantern.BaseNode.TYPES.NETWORK) {
       return this._estimateNetworkTimeRemaining(node);
     } else {
       throw new Error('Unsupported');
@@ -401,13 +400,13 @@ class Simulator {
     const timingData = this._nodeTimings.getInProgress(node);
     const isFinished = timingData.estimatedTimeElapsed === timePeriodLength;
 
-    if (node.type === BaseNode.TYPES.CPU || node.isConnectionless) {
+    if (node.type === Lantern.BaseNode.TYPES.CPU || node.isConnectionless) {
       return isFinished
         ? this._markNodeAsComplete(node, totalElapsedTime)
         : (timingData.timeElapsed += timePeriodLength);
     }
 
-    if (node.type !== BaseNode.TYPES.NETWORK) throw new Error('Unsupported');
+    if (node.type !== Lantern.BaseNode.TYPES.NETWORK) throw new Error('Unsupported');
     if (!('bytesDownloaded' in timingData)) throw new Error('Invalid timing data');
 
     const request = node.request;
@@ -488,7 +487,7 @@ class Simulator {
    * @return {Lantern.Simulation.Result<T>}
    */
   simulate(graph, options) {
-    if (BaseNode.hasCycle(graph)) {
+    if (Lantern.BaseNode.hasCycle(graph)) {
       throw new Error('Cannot simulate graph with cycle');
     }
 

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

@@ -0,0 +1,434 @@
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'assert/strict';
+
+import * as Lantern from '../lantern.js';
+import {readJson} from '../../../test/test-utils.js';
+import {runTraceEngine} from '../../../test/lib/lantern/metrics/MetricTestUtils.js';
+
+const {NetworkNode, CPUNode} = Lantern;
+const {Simulator, DNSCache} = Lantern.Simulation;
+
+const pwaTrace = readJson('../../../fixtures/artifacts/progressive-app/trace.json', import.meta);
+
+let nextRequestId = 1;
+let nextTid = 1;
+
+/**
+ * @param {Lantern.Trace} trace
+ */
+async function createGraph(trace) {
+  const traceEngineData = await runTraceEngine(trace.traceEvents);
+  const requests =
+    Lantern.TraceEngineComputationData.createNetworkRequests(trace, traceEngineData);
+  return Lantern.TraceEngineComputationData.createGraph(requests, trace, traceEngineData);
+}
+
+function request(opts) {
+  const scheme = opts.scheme || 'http';
+  const url = `${scheme}://example.com`;
+  const rendererStartTime = opts.startTime;
+  const networkEndTime = opts.endTime;
+  delete opts.startTime;
+  delete opts.endTime;
+
+  return Object.assign({
+    requestId: opts.requestId || nextRequestId++,
+    url,
+    transferSize: opts.transferSize || 1000,
+    protocol: scheme,
+    parsedURL: {scheme, host: 'example.com', securityOrigin: url},
+    timing: opts.timing,
+    rendererStartTime,
+    networkEndTime,
+  }, opts);
+}
+
+function cpuTask({tid, ts, duration}) {
+  tid = tid || nextTid++;
+  ts = ts || 0;
+  const dur = ((duration || 0) * 1000) / 5;
+  return {tid, ts, dur};
+}
+describe('DependencyGraph/Simulator', () => {
+  // Insulate the simulator tests from DNS multiplier changes
+  let originalDNSMultiplier;
+
+  before(() => {
+    originalDNSMultiplier = DNSCache.RTT_MULTIPLIER;
+    DNSCache.RTT_MULTIPLIER = 1;
+  });
+
+  after(() => {
+    DNSCache.RTT_MULTIPLIER = originalDNSMultiplier;
+  });
+
+  describe('.simulate', () => {
+    const serverResponseTimeByOrigin = new Map([['http://example.com', 500]]);
+
+    function assertNodeTiming(result, node, assertions) {
+      const timing = result.nodeTimings.get(node);
+      assert.ok(timing, 'missing node timing information');
+      Object.keys(assertions).forEach(key => {
+        assert.equal(timing[key], assertions[key]);
+      });
+    }
+
+    it('should simulate basic network graphs', () => {
+      const rootNode = new NetworkNode(request({}));
+      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const result = simulator.simulate(rootNode);
+      // should be 3 RTTs and 500ms for the server response time
+      assert.equal(result.timeInMs, 450 + 500);
+      assertNodeTiming(result, rootNode, {startTime: 0, endTime: 950});
+    });
+
+    it('should simulate basic mixed graphs', () => {
+      const rootNode = new NetworkNode(request({}));
+      const cpuNode = new CPUNode(cpuTask({duration: 200}));
+      cpuNode.addDependency(rootNode);
+
+      const simulator = new Simulator({
+        serverResponseTimeByOrigin,
+        cpuSlowdownMultiplier: 5,
+      });
+      const result = simulator.simulate(rootNode);
+      // should be 3 RTTs and 500ms for the server response time + 200 CPU
+      assert.equal(result.timeInMs, 450 + 500 + 200);
+      assertNodeTiming(result, rootNode, {startTime: 0, endTime: 950});
+      assertNodeTiming(result, cpuNode, {startTime: 950, endTime: 1150});
+    });
+
+    it('should simulate basic network waterfall graphs', () => {
+      const nodeA = new NetworkNode(request({startTime: 0, endTime: 1}));
+      const nodeB = new NetworkNode(request({startTime: 0, endTime: 3}));
+      const nodeC = new NetworkNode(request({startTime: 0, endTime: 5}));
+      const nodeD = new NetworkNode(request({startTime: 0, endTime: 7}));
+
+      nodeA.addDependent(nodeB);
+      nodeB.addDependent(nodeC);
+      nodeC.addDependent(nodeD);
+
+      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const result = simulator.simulate(nodeA);
+      // should be 950ms for A, 650ms each for B, C, D (no DNS and one-way connection)
+      assert.equal(result.timeInMs, 2900);
+      assertNodeTiming(result, nodeA, {startTime: 0, endTime: 950});
+      assertNodeTiming(result, nodeB, {startTime: 950, endTime: 1600});
+      assertNodeTiming(result, nodeC, {startTime: 1600, endTime: 2250});
+      assertNodeTiming(result, nodeD, {startTime: 2250, endTime: 2900});
+    });
+
+    it('should simulate cached network graphs', () => {
+      const nodeA = new NetworkNode(request({startTime: 0, endTime: 1,
+        fromDiskCache: true}));
+      const nodeB = new NetworkNode(request({startTime: 0, endTime: 3,
+        fromDiskCache: true}));
+      nodeA.addDependent(nodeB);
+
+      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const result = simulator.simulate(nodeA);
+      // should be ~8ms each for A, B
+      assert.equal(result.timeInMs, 16);
+      assertNodeTiming(result, nodeA, {startTime: 0, endTime: 8});
+      assertNodeTiming(result, nodeB, {startTime: 8, endTime: 16});
+    });
+
+    it('should simulate data URL network graphs', () => {
+      const url = 'data:image/jpeg;base64,foobar';
+      const protocol = 'data';
+      const parsedURL = {scheme: 'data', host: '', securityOrigin: 'null'};
+      const nodeA = new NetworkNode(request({startTime: 0, endTime: 1, url,
+        parsedURL, protocol}));
+      const nodeB = new NetworkNode(request({startTime: 0, endTime: 3, url,
+        parsedURL, protocol, resourceSize: 1024 * 1024}));
+      nodeA.addDependent(nodeB);
+
+      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const result = simulator.simulate(nodeA);
+
+      // should be ~2ms for A (resourceSize 0), ~12ms for B (resourceSize 1MB)
+      assert.equal(result.timeInMs, 14);
+      assertNodeTiming(result, nodeA, {startTime: 0, endTime: 2});
+      assertNodeTiming(result, nodeB, {startTime: 2, endTime: 14});
+    });
+
+    it('should simulate basic CPU queue graphs', () => {
+      const nodeA = new NetworkNode(request({}));
+      const nodeB = new CPUNode(cpuTask({duration: 100}));
+      const nodeC = new CPUNode(cpuTask({duration: 600}));
+      const nodeD = new CPUNode(cpuTask({duration: 300}));
+
+      nodeA.addDependent(nodeB);
+      nodeA.addDependent(nodeC);
+      nodeA.addDependent(nodeD);
+
+      const simulator = new Simulator({
+        serverResponseTimeByOrigin,
+        cpuSlowdownMultiplier: 5,
+      });
+      const result = simulator.simulate(nodeA);
+      // should be 800ms A, then 1000 ms total for B, C, D in serial
+      assert.equal(result.timeInMs, 1950);
+      assertNodeTiming(result, nodeA, {startTime: 0, endTime: 950});
+      assertNodeTiming(result, nodeB, {startTime: 950, endTime: 1050});
+      assertNodeTiming(result, nodeC, {startTime: 1050, endTime: 1650});
+      assertNodeTiming(result, nodeD, {startTime: 1650, endTime: 1950});
+    });
+
+    it('should simulate basic network waterfall graphs with CPU', () => {
+      const nodeA = new NetworkNode(request({}));
+      const nodeB = new NetworkNode(request({}));
+      const nodeC = new NetworkNode(request({}));
+      const nodeD = new NetworkNode(request({}));
+      const nodeE = new CPUNode(cpuTask({duration: 1000}));
+      const nodeF = new CPUNode(cpuTask({duration: 1000}));
+
+      nodeA.addDependent(nodeB);
+      nodeB.addDependent(nodeC);
+      nodeB.addDependent(nodeE); // finishes 350 ms after C
+      nodeC.addDependent(nodeD);
+      nodeC.addDependent(nodeF); // finishes 700 ms after D
+
+      const simulator = new Simulator({
+        serverResponseTimeByOrigin,
+        cpuSlowdownMultiplier: 5,
+      });
+      const result = simulator.simulate(nodeA);
+      // should be 950ms for A, 650ms each for B, C, D, with F finishing 700 ms after D
+      assert.equal(result.timeInMs, 3600);
+    });
+
+    it('should simulate basic parallel requests', () => {
+      const nodeA = new NetworkNode(request({}));
+      const nodeB = new NetworkNode(request({}));
+      const nodeC = new NetworkNode(request({transferSize: 15000}));
+      const nodeD = new NetworkNode(request({}));
+
+      nodeA.addDependent(nodeB);
+      nodeA.addDependent(nodeC);
+      nodeA.addDependent(nodeD);
+
+      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const result = simulator.simulate(nodeA);
+      // should be 950ms for A and 950ms for C (2 round trips of downloading, but no DNS)
+      assert.equal(result.timeInMs, 950 + 950);
+    });
+
+    it('should make connections in parallel', () => {
+      const nodeA = new NetworkNode(request({startTime: 0, networkRequestTime: 0, endTime: 1}));
+      const nodeB = new NetworkNode(request({startTime: 2, networkRequestTime: 2, endTime: 3}));
+      const nodeC = new NetworkNode(request({startTime: 2, networkRequestTime: 2, endTime: 5}));
+      const nodeD = new NetworkNode(request({startTime: 2, networkRequestTime: 2, endTime: 7}));
+
+      nodeA.addDependent(nodeB);
+      nodeA.addDependent(nodeC);
+      nodeA.addDependent(nodeD);
+
+      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const result = simulator.simulate(nodeA);
+      // should be 950ms for A, 650ms for B reusing connection, 800ms for C and D in parallel.
+      assert.equal(result.timeInMs, 950 + 800);
+      assertNodeTiming(result, nodeA, {startTime: 0, endTime: 950});
+      assertNodeTiming(result, nodeB, {startTime: 950, endTime: 1600});
+      assertNodeTiming(result, nodeC, {startTime: 950, endTime: 1750});
+      assertNodeTiming(result, nodeD, {startTime: 950, endTime: 1750});
+    });
+
+    it('should adjust throughput based on number of requests', () => {
+      const nodeA = new NetworkNode(request({}));
+      const nodeB = new NetworkNode(request({}));
+      const nodeC = new NetworkNode(request({transferSize: 14000}));
+      const nodeD = new NetworkNode(request({}));
+
+      nodeA.addDependent(nodeB);
+      nodeA.addDependent(nodeC);
+      nodeA.addDependent(nodeD);
+
+      // 80 kbps while all 3 download at 150ms/RT = ~1460 bytes/RT
+      // 240 kbps while the last one finishes at 150ms/RT = ~4380 bytes/RT
+      // ~14000 bytes = 5 RTs
+      // 1 RT 80 kbps b/c its shared
+      // 1 RT 80 kbps b/c it needs to grow congestion window from being shared
+      // 1 RT 160 kbps b/c TCP
+      // 2 RT 240 kbps b/c throughput cap
+      const simulator = new Simulator({serverResponseTimeByOrigin, throughput: 240000});
+      const result = simulator.simulate(nodeA);
+      // should be 950ms for A and 1400ms for C (5 round trips of downloading)
+      assert.equal(result.timeInMs, 950 + (150 + 750 + 500));
+    });
+
+    it('should start network requests in startTime order', () => {
+      const rootNode = new NetworkNode(request({startTime: 0, endTime: 0.05,
+        connectionId: 1}));
+      const imageNodes = [
+        new NetworkNode(request({startTime: 5})),
+        new NetworkNode(request({startTime: 4})),
+        new NetworkNode(request({startTime: 3})),
+        new NetworkNode(request({startTime: 2})),
+        new NetworkNode(request({startTime: 1})),
+      ];
+
+      for (const imageNode of imageNodes) {
+        imageNode.request.connectionReused = true;
+        imageNode.request.connectionId = 1;
+        rootNode.addDependent(imageNode);
+      }
+
+      const simulator = new Simulator({serverResponseTimeByOrigin, maximumConcurrentRequests: 1});
+      const result = simulator.simulate(rootNode);
+
+      // should be 3 RTs + SRT for rootNode (950ms)
+      // should be 1 RT  + SRT for image nodes in observed order (650ms)
+      assertNodeTiming(result, rootNode, {startTime: 0, endTime: 950});
+      assertNodeTiming(result, imageNodes[4], {startTime: 950, endTime: 1600});
+      assertNodeTiming(result, imageNodes[3], {startTime: 1600, endTime: 2250});
+      assertNodeTiming(result, imageNodes[2], {startTime: 2250, endTime: 2900});
+      assertNodeTiming(result, imageNodes[1], {startTime: 2900, endTime: 3550});
+      assertNodeTiming(result, imageNodes[0], {startTime: 3550, endTime: 4200});
+    });
+
+    it('should start network requests in priority order to break startTime ties', () => {
+      const rootNode = new NetworkNode(request({startTime: 0, endTime: 0.05,
+        connectionId: 1}));
+      const imageNodes = [
+        new NetworkNode(request({startTime: 0.1, priority: 'VeryLow'})),
+        new NetworkNode(request({startTime: 0.2, priority: 'Low'})),
+        new NetworkNode(request({startTime: 0.3, priority: 'Medium'})),
+        new NetworkNode(request({startTime: 0.4, priority: 'High'})),
+        new NetworkNode(request({startTime: 0.5, priority: 'VeryHigh'})),
+      ];
+
+      for (const imageNode of imageNodes) {
+        imageNode.request.connectionReused = true;
+        imageNode.request.connectionId = 1;
+        rootNode.addDependent(imageNode);
+      }
+
+      const simulator = new Simulator({serverResponseTimeByOrigin, maximumConcurrentRequests: 1});
+      const result = simulator.simulate(rootNode);
+
+      // should be 3 RTs + SRT for rootNode (950ms)
+      // should be 1 RT  + SRT for image nodes in priority order (650ms)
+      assertNodeTiming(result, rootNode, {startTime: 0, endTime: 950});
+      assertNodeTiming(result, imageNodes[4], {startTime: 950, endTime: 1600});
+      assertNodeTiming(result, imageNodes[3], {startTime: 1600, endTime: 2250});
+      assertNodeTiming(result, imageNodes[2], {startTime: 2250, endTime: 2900});
+      assertNodeTiming(result, imageNodes[1], {startTime: 2900, endTime: 3550});
+      assertNodeTiming(result, imageNodes[0], {startTime: 3550, endTime: 4200});
+    });
+
+    it('should simulate two graphs in a row', () => {
+      const simulator = new Simulator({serverResponseTimeByOrigin});
+
+      const nodeA = new NetworkNode(request({}));
+      const nodeB = new NetworkNode(request({}));
+      const nodeC = new NetworkNode(request({transferSize: 15000}));
+      const nodeD = new NetworkNode(request({}));
+
+      nodeA.addDependent(nodeB);
+      nodeA.addDependent(nodeC);
+      nodeA.addDependent(nodeD);
+
+      const resultA = simulator.simulate(nodeA);
+      // should be 950ms for A and 950ms for C (2 round trips of downloading, no DNS)
+      assert.equal(resultA.timeInMs, 950 + 950);
+
+      const nodeE = new NetworkNode(request({}));
+      const nodeF = new NetworkNode(request({}));
+      const nodeG = new NetworkNode(request({}));
+
+      nodeE.addDependent(nodeF);
+      nodeE.addDependent(nodeG);
+
+      const resultB = simulator.simulate(nodeE);
+      // should be 950ms for E and 800ms for F/G
+      assert.equal(resultB.timeInMs, 950 + 800);
+    });
+
+    it('should maximize throughput with H2', () => {
+      const simulator = new Simulator({serverResponseTimeByOrigin});
+      const connectionDefaults = {protocol: 'h2', connectionId: 1};
+      const nodeA = new NetworkNode(request({startTime: 0, endTime: 1,
+        ...connectionDefaults}));
+      const nodeB = new NetworkNode(request({startTime: 1, endTime: 2,
+        ...connectionDefaults}));
+      const nodeC = new NetworkNode(request({startTime: 2, endTime: 3,
+        ...connectionDefaults}));
+      const nodeD = new NetworkNode(request({startTime: 3, endTime: 4,
+        ...connectionDefaults}));
+
+      nodeA.addDependent(nodeB);
+      nodeB.addDependent(nodeC);
+      nodeB.addDependent(nodeD);
+
+      // Run two simulations:
+      //  - The first with C & D in parallel.
+      //  - The second with C & D in series.
+      // Under HTTP/2 simulation these should be equivalent, but definitely parallel
+      // shouldn't be slower.
+      const resultA = simulator.simulate(nodeA);
+      nodeC.addDependent(nodeD);
+      const resultB = simulator.simulate(nodeA);
+      expect(resultA.timeInMs).toBeLessThanOrEqual(resultB.timeInMs);
+    });
+
+    it('should throw (not hang) on graphs with cycles', () => {
+      const rootNode = new NetworkNode(request({}));
+      const depNode = new NetworkNode(request({}));
+      rootNode.addDependency(depNode);
+      depNode.addDependency(rootNode);
+
+      const simulator = new Simulator({serverResponseTimeByOrigin});
+      assert.throws(() => simulator.simulate(rootNode), /cycle/);
+    });
+
+    describe('on a real trace', () => {
+      const trace = pwaTrace;
+
+      it('should compute a timeInMs', async () => {
+        const graph = await createGraph(trace);
+        const simulator = new Simulator({serverResponseTimeByOrigin});
+        const result = simulator.simulate(graph);
+        expect(result.timeInMs).toBeGreaterThan(100);
+      });
+
+      it('should sort the task event times', async () => {
+        const graph = await createGraph(trace);
+        const simulator = new Simulator({serverResponseTimeByOrigin});
+        const result = simulator.simulate(graph);
+        const nodeTimings = Array.from(result.nodeTimings.entries());
+
+        for (let i = 1; i < nodeTimings.length; i++) {
+          const startTime = nodeTimings[i][1].startTime;
+          const previousStartTime = nodeTimings[i - 1][1].startTime;
+          expect(startTime).toBeGreaterThanOrEqual(previousStartTime);
+        }
+      });
+    });
+  });
+
+  describe('.simulateTimespan', () => {
+    it('calculates savings using throughput', () => {
+      const simulator = new Simulator({throughput: 1000, observedThroughput: 2000});
+      const wastedMs = simulator.computeWastedMsFromWastedBytes(500);
+      expect(wastedMs).toBeCloseTo(4000);
+    });
+
+    it('falls back to observed throughput if throughput is 0', () => {
+      const simulator = new Simulator({throughput: 0, observedThroughput: 2000});
+      const wastedMs = simulator.computeWastedMsFromWastedBytes(500);
+      expect(wastedMs).toBeCloseTo(2000);
+    });
+
+    it('returns 0 if throughput and observed throughput are 0', () => {
+      const simulator = new Simulator({throughput: 0, observedThroughput: 0});
+      const wastedMs = simulator.computeWastedMsFromWastedBytes(500);
+      expect(wastedMs).toEqual(0);
+    });
+  });
+});

package/core/lib/lantern/simulation/TCPConnection.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=TCPConnection.test.d.ts.map