relay-test-utils-internal 13.1.1 → 14.1.0

package/trackRetentionForEnvironment.js.flow

@@ -0,0 +1,63 @@
+/**
+ * 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
+ * @format
+ */
+
+'use strict';
+
+/* global jest */
+
+import type {IEnvironment} from '../relay-runtime';
+import type {OperationDescriptor} from '../relay-runtime/store/RelayStoreTypes';
+
+/**
+ * Takes an environment and augments it with a mock implementation of `retain`
+ * that tracks what operations are currently retained. Also returns the Jest mock
+ * `release` function for backwards-compatibility with existing tests, but you
+ * should use `isOperationRetained` for new tests as it is much less error-prone.
+ */
+function trackRetentionForEnvironment(environment: IEnvironment): {
+  release_DEPRECATED: JestMockFn<[mixed], void>,
+  isOperationRetained: OperationDescriptor => boolean,
+} {
+  const retainCountsByOperation = new Map();
+
+  const release = jest.fn(id => {
+    const existing = retainCountsByOperation.get(id) ?? NaN;
+    if (existing === 1) {
+      retainCountsByOperation.delete(id);
+    } else {
+      retainCountsByOperation.set(id, existing - 1);
+    }
+  });
+
+  // $FlowFixMe[cannot-write] safe to do for mocking
+  environment.retain = jest.fn(operation => {
+    const id = operation.request.identifier;
+    const existing = retainCountsByOperation.get(id) ?? 0;
+    retainCountsByOperation.set(id, existing + 1);
+    let released = false;
+    return {
+      dispose: () => {
+        if (!released) {
+          release(id);
+        }
+        released = true;
+      },
+    };
+  });
+
+  function isOperationRetained(operation: OperationDescriptor) {
+    const id = operation.request.identifier;
+    return (retainCountsByOperation.get(id) ?? 0) > 0;
+  }
+
+  return {release_DEPRECATED: release, isOperationRetained};
+}
+
+module.exports = trackRetentionForEnvironment;

package/warnings.js.flow

@@ -11,11 +11,27 @@
 
 'use strict';
 
-/* global jest, afterEach */
+/* global jest */
 
-let installed = false;
-const expectedWarnings: Array<string> = [];
-const contextualExpectedWarning: Array<string> = [];
+import type {WillFireOptions} from './consoleErrorsAndWarnings';
+
+const {createConsoleInterceptionSystem} = require('./consoleErrorsAndWarnings');
+
+const warningsSystem = createConsoleInterceptionSystem(
+  'warning',
+  'expectToWarn',
+  impl => {
+    jest.mock('warning', () =>
+      jest.fn((condition, format, ...args) => {
+        if (!condition) {
+          let argIndex = 0;
+          const message = format.replace(/%s/g, () => String(args[argIndex++]));
+          impl(message);
+        }
+      }),
+    );
+  },
+);
 
 /**
  * Mocks the `warning` module to turn warnings into errors. Any expected
@@ -25,64 +41,25 @@ const contextualExpectedWarning: Array<string> = [];
  *       use `jest.resetModules()` or manually mock `warning`.
  */
 function disallowWarnings(): void {
-  if (installed) {
-    throw new Error('`disallowWarnings` should be called at most once');
-  }
-  installed = true;
-  jest.mock('warning', () => {
-    return jest.fn((condition, format, ...args) => {
-      if (!condition) {
-        let argIndex = 0;
-        const message = format.replace(/%s/g, () => String(args[argIndex++]));
-        const index = expectedWarnings.indexOf(message);
-
-        if (
-          contextualExpectedWarning.length > 0 &&
-          contextualExpectedWarning[0] === message
-        ) {
-          contextualExpectedWarning.shift();
-        } else if (index >= 0) {
-          expectedWarnings.splice(index, 1);
-        } else {
-          // log to console in case the error gets swallowed somewhere
-          console.error('Unexpected Warning: ' + message);
-          throw new Error('Warning: ' + message);
-        }
-      }
-    });
-  });
-  afterEach(() => {
-    contextualExpectedWarning.length = 0;
-    if (expectedWarnings.length > 0) {
-      const error = new Error(
-        'Some expected warnings where not triggered:\n\n' +
-          Array.from(expectedWarnings, message => ` * ${message}`).join('\n') +
-          '\n',
-      );
-      expectedWarnings.length = 0;
-      throw error;
-    }
-  });
+  warningsSystem.disallowMessages();
 }
 
 /**
  * Expect a warning with the given message. If the message isn't fired in the
  * current test, the test will fail.
  */
-function expectWarningWillFire(message: string): void {
-  if (!installed) {
-    throw new Error(
-      '`disallowWarnings` needs to be called before `expectWarningWillFire`',
-    );
-  }
-  expectedWarnings.push(message);
+function expectWarningWillFire(
+  message: string,
+  options?: WillFireOptions,
+): void {
+  warningsSystem.expectMessageWillFire(message, options);
 }
 
 /**
  * Expect the callback `fn` to trigger the warning message and otherwise fail.
  */
 function expectToWarn<T>(message: string, fn: () => T): T {
-  return expectToWarnMany([message], fn);
+  return warningsSystem.expectMessage(message, fn);
 }
 
 /**
@@ -90,17 +67,7 @@ function expectToWarn<T>(message: string, fn: () => T): T {
  * or otherwise fail.
  */
 function expectToWarnMany<T>(messages: Array<string>, fn: () => T): T {
-  if (contextualExpectedWarning.length > 0) {
-    throw new Error('Cannot nest `expectToWarn()` calls.');
-  }
-  contextualExpectedWarning.push(...messages);
-  const result = fn();
-  if (contextualExpectedWarning.length > 0) {
-    const notFired = contextualExpectedWarning.toString();
-    contextualExpectedWarning.length = 0;
-    throw new Error(`Expected callback to warn: ${notFired}`);
-  }
-  return result;
+  return warningsSystem.expectMessageMany(messages, fn);
 }
 
 module.exports = {