@atlaspack/core 2.16.2-canary.48 → 2.16.2-canary.481

package/test/{RequestTracker.test.js → RequestTracker.test.ts}

@@ -1,10 +1,12 @@
-// @flow strict-local
-
 import assert from 'assert';
 import nullthrows from 'nullthrows';
 import RequestTracker, {
-  type RunAPI,
+  RunAPI,
   cleanUpOrphans,
+  runInvalidation,
+  getBiggestFSEventsInvalidations,
+  invalidateRequestGraphFSEvents,
+  requestTypes,
 } from '../src/RequestTracker';
 import {Graph} from '@atlaspack/graph';
 import {LMDBLiteCache} from '@atlaspack/cache';
@@ -14,14 +16,26 @@ import {FILE_CREATE, FILE_UPDATE, INITIAL_BUILD} from '../src/constants';
 import {makeDeferredWithPromise} from '@atlaspack/utils';
 import {toProjectPath} from '../src/projectPath';
 import {DEFAULT_FEATURE_FLAGS, setFeatureFlags} from '../../feature-flags/src';
+import sinon from 'sinon';
+import type {AtlaspackOptions} from '../src/types';
+import createAtlaspackBuildRequest from '../src/requests/AtlaspackBuildRequest';
+import Atlaspack from '../src/Atlaspack';
+import {MemoryFS, NodeFS} from '@atlaspack/fs';
+import {OverlayFS} from '../../fs/src/OverlayFS';
+import path from 'path';
+import createAssetGraphRequest from '../src/requests/AssetGraphRequest';
 
 const options = {
   ...DEFAULT_OPTIONS,
   cache: new LMDBLiteCache(DEFAULT_OPTIONS.cacheDir),
-};
-const farm = new WorkerFarm({workerPath: require.resolve('../src/worker')});
+} as const;
 
 describe('RequestTracker', () => {
+  let farm: any;
+  before(() => {
+    farm = new WorkerFarm({workerPath: require.resolve('../src/worker')});
+  });
+
   beforeEach(async () => {
     await options.cache.ensure();
 
@@ -30,6 +44,10 @@ describe('RequestTracker', () => {
     }
   });
 
+  after(() => {
+    farm.end();
+  });
+
   it('should not run requests that have not been invalidated', async () => {
     let tracker = new RequestTracker({farm, options});
     await tracker.runRequest({
@@ -79,7 +97,7 @@ describe('RequestTracker', () => {
     await tracker.runRequest({
       id: 'abc',
       type: 7,
-      run: async ({api}) => {
+      run: async ({api}: any) => {
         await api.runRequest({
           id: 'xyz',
           type: 7,
@@ -96,7 +114,7 @@ describe('RequestTracker', () => {
     assert(
       tracker
         .getInvalidRequests()
-        .map((req) => req.id)
+        .map((req: any) => req.id)
         .includes('abc'),
     );
   });
@@ -119,7 +137,7 @@ describe('RequestTracker', () => {
     assert(
       tracker
         .getInvalidRequests()
-        .map((req) => req.id)
+        .map((req: any) => req.id)
         .includes('abc'),
     );
   });
@@ -129,7 +147,7 @@ describe('RequestTracker', () => {
     await tracker.runRequest({
       id: 'abc',
       type: 7,
-      run: async ({api}) => {
+      run: async ({api}: any) => {
         await api.runRequest({
           id: 'xyz',
           type: 7,
@@ -144,7 +162,7 @@ describe('RequestTracker', () => {
     await tracker.runRequest({
       id: 'abc',
       type: 7,
-      run: async ({api}) => {
+      run: async ({api}: any) => {
         await api.runRequest({
           id: '123',
           type: 7,
@@ -162,8 +180,7 @@ describe('RequestTracker', () => {
     await tracker.runRequest({
       id: 'abc',
       type: 7,
-      // $FlowFixMe string isn't a valid result
-      run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+      run: async ({api}: {api: RunAPI<string | undefined>}) => {
         let result = await Promise.resolve('hello');
         api.storeResult(result);
       },
@@ -178,39 +195,13 @@ describe('RequestTracker', () => {
     assert(result === 'hello');
   });
 
-  it('should reject all in progress requests when the abort controller aborts', async () => {
-    let tracker = new RequestTracker({farm, options});
-    let p = tracker
-      .runRequest({
-        id: 'abc',
-        type: 7,
-        run: async () => {
-          await Promise.resolve('hello');
-        },
-        input: null,
-      })
-      .then(null, () => {
-        /* do nothing */
-      });
-    // $FlowFixMe
-    tracker.setSignal({aborted: true});
-    await p;
-    assert(
-      tracker
-        .getInvalidRequests()
-        .map((req) => req.id)
-        .includes('abc'),
-    );
-  });
-
   it('should write cache to disk and store index', async () => {
     let tracker = new RequestTracker({farm, options});
 
     await tracker.runRequest({
       id: 'abc',
       type: 7,
-      // $FlowFixMe string isn't a valid result
-      run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+      run: async ({api}: {api: RunAPI<string | undefined>}) => {
         let result = await Promise.resolve();
         api.storeResult(result);
       },
@@ -242,8 +233,7 @@ describe('RequestTracker', () => {
     let requestA = tracker.runRequest({
       id: 'abc',
       type: 7,
-      // $FlowFixMe string isn't a valid result
-      run: async ({api}: {api: RunAPI<string>, ...}) => {
+      run: async ({api}: {api: RunAPI<string>}) => {
         await lockA.promise;
         api.storeResult('a');
         return 'a';
@@ -255,8 +245,7 @@ describe('RequestTracker', () => {
     let requestB = tracker.runRequest({
       id: 'abc',
       type: 7,
-      // $FlowFixMe string isn't a valid result
-      run: async ({api}: {api: RunAPI<string>, ...}) => {
+      run: async ({api}: {api: RunAPI<string>}) => {
         calledB = true;
         await lockB.promise;
         api.storeResult('b');
@@ -305,8 +294,7 @@ describe('RequestTracker', () => {
     let requestB = tracker.runRequest({
       id: 'abc',
       type: 7,
-      // $FlowFixMe string isn't a valid result
-      run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+      run: async ({api}: {api: RunAPI<string | undefined>}) => {
         await lockB.promise;
         api.storeResult('b');
       },
@@ -408,8 +396,7 @@ describe('RequestTracker', () => {
     await tracker.runRequest({
       id: contentKey,
       type: 7,
-      // $FlowFixMe string isn't a valid result
-      run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+      run: async ({api}: {api: RunAPI<string | undefined>}) => {
         let result = await Promise.resolve('a');
         api.storeResult(result);
       },
@@ -422,8 +409,7 @@ describe('RequestTracker', () => {
       {
         id: contentKey,
         type: 7,
-        // $FlowFixMe string isn't a valid result
-        run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+        run: async ({api}: {api: RunAPI<string | undefined>}) => {
           let result = await Promise.resolve('b');
           api.storeResult(result);
         },
@@ -465,7 +451,7 @@ describe('RequestTracker', () => {
   });
 
   describe('respondToFSEvents', () => {
-    [true, false].forEach((value) => {
+    [true, false].forEach((value: any) => {
       beforeEach(() => {
         setFeatureFlags({
           ...DEFAULT_FEATURE_FLAGS,
@@ -485,8 +471,7 @@ describe('RequestTracker', () => {
           await tracker.runRequest({
             id: 'abc',
             type: 7,
-            // $FlowFixMe string isn't a valid result
-            run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+            run: async ({api}: {api: RunAPI<string | undefined>}) => {
               api.invalidateOnFileUpdate(toProjectPath('', 'my-file'));
               let result = await Promise.resolve('hello');
               api.storeResult(result);
@@ -494,7 +479,7 @@ describe('RequestTracker', () => {
             input: null,
           });
           const requestId = tracker.graph.getNodeIdByContentKey('abc');
-          const invalidated = await tracker.respondToFSEvents(
+          const {didInvalidate: invalidated} = await tracker.respondToFSEvents(
             [
               {
                 type: 'update',
@@ -518,8 +503,7 @@ describe('RequestTracker', () => {
           await tracker.runRequest({
             id: 'abc',
             type: 7,
-            // $FlowFixMe string isn't a valid result
-            run: async ({api}: {api: RunAPI<string | void>, ...}) => {
+            run: async ({api}: {api: RunAPI<string | undefined>}) => {
               api.invalidateOnFileCreate({
                 fileName: 'package.json',
                 aboveFilePath: toProjectPath(
@@ -533,7 +517,7 @@ describe('RequestTracker', () => {
             input: null,
           });
           const requestId = tracker.graph.getNodeIdByContentKey('abc');
-          const invalidated = await tracker.respondToFSEvents(
+          const {didInvalidate: invalidated} = await tracker.respondToFSEvents(
             [
               {
                 type: 'create',
@@ -574,8 +558,8 @@ root --- node1 --- node2 ----------- orphan1 --- orphan2
 
      */
 
-    const getNonNullNodes = (graph) =>
-      graph.nodes.filter((node) => node != null);
+    const getNonNullNodes = (graph: any) =>
+      graph.nodes.filter((node: any) => node != null);
 
     graph.addEdge(root, node1);
     graph.addEdge(node1, node2);
@@ -596,3 +580,97 @@ root --- node1 --- node2 ----------- orphan1 --- orphan2
     assert.equal(Array.from(graph.getAllEdges()).length, 3);
   });
 });
+
+describe('runInvalidation', () => {
+  it('calls an invalidationFn and tracks the number of invalidated nodes', async () => {
+    const mockRequestTracker = {
+      getInvalidNodeCount: sinon.stub(),
+    } as const;
+
+    mockRequestTracker.getInvalidNodeCount.returns(10000);
+    const result = await runInvalidation(mockRequestTracker, {
+      key: 'fsEvents',
+      fn: () => {
+        mockRequestTracker.getInvalidNodeCount.returns(30000);
+        return {
+          biggestInvalidations: [{path: 'my-file', count: 10000}],
+        };
+      },
+    });
+
+    assert.equal(result.key, 'fsEvents');
+    assert.equal(result.count, 20000);
+    assert.deepEqual(result.detail, {
+      biggestInvalidations: [{path: 'my-file', count: 10000}],
+    });
+    assert(result.duration > 0, 'Duration was not reported');
+  });
+});
+
+describe('invalidateRequestGraphFSEvents', () => {
+  it('calls requestGraph.respondToFSEvents and returns the biggest invalidations', async () => {
+    const requestGraph = {
+      respondToFSEvents: sinon.stub(),
+    } as const;
+
+    requestGraph.respondToFSEvents.returns({
+      invalidationsByPath: new Map([
+        ['file-1', 10],
+        ['file-2', 5000],
+        ['file-3', 8000],
+      ]),
+    });
+    const options: AtlaspackOptions = {
+      unstableFileInvalidations: undefined,
+    };
+
+    const result = await invalidateRequestGraphFSEvents(requestGraph, options, [
+      {
+        path: 'file-1',
+        type: 'create',
+      },
+      {
+        path: 'file-2',
+        type: 'update',
+      },
+      {
+        path: 'file-3',
+        type: 'delete',
+      },
+    ]);
+
+    assert.deepEqual(result.biggestInvalidations, [
+      {path: 'file-3', count: 8000},
+      {path: 'file-2', count: 5000},
+      {path: 'file-1', count: 10},
+    ]);
+    assert.equal(requestGraph.respondToFSEvents.callCount, 1);
+    assert.deepEqual(requestGraph.respondToFSEvents.args[0], [
+      [
+        {path: 'file-1', type: 'create'},
+        {path: 'file-2', type: 'update'},
+        {path: 'file-3', type: 'delete'},
+      ],
+      options,
+      10000,
+      true,
+    ]);
+  });
+});
+
+describe('getBiggestFSEventsInvalidations', () => {
+  it('returns the paths that invalidated the most nodes', () => {
+    const invalidationsByPath = new Map([
+      ['file-1', 10],
+      ['file-2', 5000],
+      ['file-3', 8000],
+      ['file-4', 1000],
+      ['file-5', 1000],
+    ]);
+
+    assert.deepEqual(getBiggestFSEventsInvalidations(invalidationsByPath, 2), [
+      {path: 'file-3', count: 8000},
+      {path: 'file-2', count: 5000},
+    ]);
+  });
+});