Handle missing asserted-states in Watchman subscribe response

Summary:
By #1022, Watchman may send a `subscribe` response with null or undefined `asserted-states`.

`asserted-states` were added in facebook/watchman@b114886 without an associated "capability". *Some versions of Watchman, e.g. 4.9.4, pass all of our required capability checks but don't include this field.*

This makes `#deferringStates` nullable, and only used on `state-enter` / `state-leave` if `asserted-states` is present in the subscription response. (This prevents underreporting states in the case that the subscription is initially deferred.)

Changelog:
```
 - **[Fix]**: asserted-states is not iterable when using older Watchman versions.
```

Reviewed By: motiz88

Differential Revision: D47216959

fbshipit-source-id: 4f6d75958902737080afe2feea163ed3d976da29

Author: robhogan

flow-typed/fb-watchman.js

@@ -24,7 +24,7 @@ declare module 'fb-watchman' {
     ...WatchmanBaseResponse,
     subscribe: string,
     warning?: string,
-    'asserted-states': $ReadOnlyArray<string>,
+    'asserted-states'?: $ReadOnlyArray<string>,
   }>;
 
   declare type WatchmanWatchResponse = $ReadOnly<{

packages/metro-file-map/src/watchers/WatchmanWatcher.js

@@ -53,7 +53,7 @@ export default class WatchmanWatcher extends EventEmitter {
     root: string,
   }>;
   watchmanDeferStates: $ReadOnlyArray<string>;
-  #deferringStates: Set<string> = new Set();
+  #deferringStates: ?Set<string> = null;
 
   constructor(dir: string, opts: WatcherOptions) {
     super();
@@ -164,8 +164,8 @@ export default class WatchmanWatcher extends EventEmitter {
 
       handleWarning(resp);
 
-      for (const state of resp['asserted-states']) {
-        this.#deferringStates.add(state);
+      if (resp['asserted-states'] != null) {
+        this.#deferringStates = new Set(resp['asserted-states']);
       }
 
       self.emit('ready');
@@ -207,7 +207,7 @@ export default class WatchmanWatcher extends EventEmitter {
       stateEnter != null &&
       (this.watchmanDeferStates ?? []).includes(stateEnter)
     ) {
-      this.#deferringStates.add(stateEnter);
+      this.#deferringStates?.add(stateEnter);
       debug(
         'Watchman reports "%s" just started. Filesystem notifications are paused.',
         stateEnter,
@@ -217,7 +217,7 @@ export default class WatchmanWatcher extends EventEmitter {
       stateLeave != null &&
       (this.watchmanDeferStates ?? []).includes(stateLeave)
     ) {
-      this.#deferringStates.delete(stateLeave);
+      this.#deferringStates?.delete(stateLeave);
       debug(
         'Watchman reports "%s" ended. Filesystem notifications resumed.',
         stateLeave,
@@ -318,21 +318,21 @@ export default class WatchmanWatcher extends EventEmitter {
   async close() {
     this.client.removeAllListeners();
     this.client.end();
-    this.#deferringStates.clear();
+    this.#deferringStates = null;
   }
 
   getPauseReason(): ?string {
-    if (this.#deferringStates.size) {
-      const states = [...this.#deferringStates];
-      if (states.length === 1) {
-        return `The watch is in the '${states[0]}' state.`;
-      }
-      return `The watch is in the ${states
-        .slice(0, -1)
-        .map(s => `'${s}'`)
-        .join(', ')} and '${states[states.length - 1]}' states.`;
+    if (this.#deferringStates == null || this.#deferringStates.size === 0) {
+      return null;
+    }
+    const states = [...this.#deferringStates];
+    if (states.length === 1) {
+      return `The watch is in the '${states[0]}' state.`;
     }
-    return null;
+    return `The watch is in the ${states
+      .slice(0, -1)
+      .map(s => `'${s}'`)
+      .join(', ')} and '${states[states.length - 1]}' states.`;
   }
 }
 

packages/metro-file-map/src/watchers/__tests__/WatchmanWatcher-test.js

@@ -0,0 +1,163 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ * @oncall react_native
+ */
+
+import type {
+  WatchmanSubscribeResponse,
+  WatchmanClockResponse,
+  WatchmanWatchResponse,
+} from 'fb-watchman';
+import WatchmanWatcher from '../WatchmanWatcher';
+import EventEmitter from 'events';
+
+class MockClient extends EventEmitter {
+  command: JestMockFn<$ReadOnlyArray<$FlowFixMe>, mixed> = jest.fn();
+}
+const mockClient = new MockClient();
+
+const cmdCallback = <T>(err: ?Error, result: Partial<T>): void => {
+  expect(mockClient.command.mock.lastCall[1]).toEqual(expect.any(Function));
+  mockClient.command.mock.lastCall[1](err, result);
+};
+
+jest.mock('fb-watchman', () => ({
+  Client: jest.fn().mockImplementation(() => mockClient),
+}));
+
+describe('WatchmanWatcher', () => {
+  test('initializes with watch-project, clock, subscribe', () => {
+    const watchmanWatcher = new WatchmanWatcher('/project/subdir/js', {
+      dot: true,
+      ignored: false,
+      glob: ['**/*.js'],
+      watchmanDeferStates: ['busy'],
+    });
+    const readyListener = jest.fn();
+    watchmanWatcher.on('ready', readyListener);
+
+    expect(mockClient.command).toHaveBeenCalledWith(
+      ['watch-project', '/project/subdir/js'],
+      expect.any(Function),
+    );
+    cmdCallback<WatchmanWatchResponse>(null, {
+      watch: '/project',
+      relative_path: 'subdir/js',
+    });
+
+    expect(mockClient.command).toHaveBeenCalledWith(
+      ['clock', '/project'],
+      expect.any(Function),
+    );
+    cmdCallback<WatchmanClockResponse>(null, {
+      clock: 'c:1629095304.251049',
+    });
+
+    expect(mockClient.command).toHaveBeenCalledWith(
+      [
+        'subscribe',
+        '/project',
+        watchmanWatcher.subscriptionName,
+        {
+          defer: ['busy'],
+          fields: ['name', 'exists', 'new', 'type', 'size', 'mtime_ms'],
+          relative_root: 'subdir/js',
+          since: 'c:1629095304.251049',
+        },
+      ],
+      expect.any(Function),
+    );
+
+    expect(readyListener).not.toHaveBeenCalled();
+    cmdCallback<WatchmanSubscribeResponse>(null, {});
+    expect(readyListener).toHaveBeenCalled();
+  });
+
+  describe('getPauseReason', () => {
+    let watchmanWatcher: WatchmanWatcher;
+
+    beforeEach(() => {
+      watchmanWatcher = new WatchmanWatcher('/project/subdir/js', {
+        dot: true,
+        ignored: false,
+        glob: ['**/*.js'],
+        watchmanDeferStates: ['busy'],
+      });
+      cmdCallback<WatchmanWatchResponse>(null, {});
+      cmdCallback<WatchmanClockResponse>(null, {});
+    });
+
+    test('subscribe response is initally deferred', () => {
+      cmdCallback<WatchmanSubscribeResponse>(null, {
+        'asserted-states': ['busy'],
+      });
+      expect(watchmanWatcher.getPauseReason()).toMatch(/busy/);
+      mockClient.emit('subscription', {
+        subscription: watchmanWatcher.subscriptionName,
+        'state-leave': 'busy',
+      });
+      expect(watchmanWatcher.getPauseReason()).toBe(null);
+    });
+
+    test('unknown states are ignored', () => {
+      cmdCallback<WatchmanSubscribeResponse>(null, {
+        'asserted-states': [],
+      });
+      mockClient.emit('subscription', {
+        subscription: watchmanWatcher.subscriptionName,
+        'state-enter': 'unknown-state',
+      });
+      expect(watchmanWatcher.getPauseReason()).toBe(null);
+      mockClient.emit('subscription', {
+        subscription: watchmanWatcher.subscriptionName,
+        'state-enter': 'busy',
+      });
+      expect(watchmanWatcher.getPauseReason()).toMatch(/busy/);
+    });
+
+    test('known states are reported and cleared', () => {
+      cmdCallback<WatchmanSubscribeResponse>(null, {
+        'asserted-states': [],
+      });
+      mockClient.emit('subscription', {
+        subscription: watchmanWatcher.subscriptionName,
+        'state-enter': 'busy',
+      });
+      expect(watchmanWatcher.getPauseReason()).toMatch(/busy/);
+      mockClient.emit('subscription', {
+        subscription: watchmanWatcher.subscriptionName,
+        'state-leave': 'busy',
+      });
+      expect(watchmanWatcher.getPauseReason()).toBe(null);
+    });
+
+    test('missing asserted-states in subscribe response', () => {
+      cmdCallback<WatchmanSubscribeResponse>(null, {});
+      expect(watchmanWatcher.getPauseReason()).toBe(null);
+      mockClient.emit('subscription', {
+        subscription: watchmanWatcher.subscriptionName,
+        'state-enter': 'busy',
+      });
+      // We don't know the original states, so don't attempt to report states.
+      expect(watchmanWatcher.getPauseReason()).toBe(null);
+    });
+
+    test('empty asserted-states in subscribe response', () => {
+      cmdCallback<WatchmanSubscribeResponse>(null, {
+        'asserted-states': [],
+      });
+      expect(watchmanWatcher.getPauseReason()).toBe(null);
+      mockClient.emit('subscription', {
+        subscription: watchmanWatcher.subscriptionName,
+        'state-enter': 'busy',
+      });
+      expect(watchmanWatcher.getPauseReason()).toMatch(/busy/);
+    });
+  });
+});