relay-test-utils-internal 13.1.1 → 14.1.0

package/consoleError.js.flow

@@ -0,0 +1,70 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+/* global jest */
+
+import type {WillFireOptions} from './consoleErrorsAndWarnings';
+
+const {createConsoleInterceptionSystem} = require('./consoleErrorsAndWarnings');
+
+const consoleErrorsSystem = createConsoleInterceptionSystem(
+  'error',
+  'expectConsoleError',
+  impl => {
+    jest.spyOn(console, 'error').mockImplementation(impl);
+  },
+);
+
+/**
+ * Mocks console.error so that errors printed to the console are instead thrown.
+ * Any expected errors need to be explicitly expected with `expectConsoleErrorWillFire(message)`.
+ *
+ * NOTE: This should be called on top of a test file. The test should NOT
+ *       use `jest.resetModules()` or manually mock `console`.
+ */
+function disallowConsoleErrors(): void {
+  consoleErrorsSystem.disallowMessages();
+}
+
+/**
+ * Expect an error with the given message. If the message isn't fired in the
+ * current test, the test will fail.
+ */
+function expectConsoleErrorWillFire(
+  message: string,
+  options?: WillFireOptions,
+): void {
+  consoleErrorsSystem.expectMessageWillFire(message, options);
+}
+
+/**
+ * Expect the callback `fn` to print an error with the message, and otherwise fail.
+ */
+function expectConsoleError<T>(message: string, fn: () => T): T {
+  return consoleErrorsSystem.expectMessage(message, fn);
+}
+
+/**
+ * Expect the callback `fn` to trigger all console errors (in sequence),
+ * and otherwise fail.
+ */
+function expectConsoleErrorsMany<T>(messages: Array<string>, fn: () => T): T {
+  return consoleErrorsSystem.expectMessageMany(messages, fn);
+}
+
+module.exports = {
+  disallowConsoleErrors,
+  expectConsoleErrorWillFire,
+  expectConsoleError,
+  expectConsoleErrorsMany,
+};

package/consoleErrorsAndWarnings.js.flow

@@ -0,0 +1,134 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+/* global afterEach */
+
+export type WillFireOptions = {
+  count?: number,
+  optional?: boolean,
+};
+
+type API = $ReadOnly<{
+  disallowMessages: () => void,
+  expectMessageWillFire: (string, void | WillFireOptions) => void,
+  expectMessage: <T>(string, () => T) => T,
+  expectMessageMany: <T>(Array<string>, () => T) => T,
+}>;
+
+const originalConsoleError = console.error;
+
+function createConsoleInterceptionSystem(
+  typename: string,
+  expectFunctionName: string,
+  setUpMock: ((string) => void) => void,
+): API {
+  let installed = false;
+  const expectedMessages: Array<string> = [];
+  const optionalMessages: Array<string> = [];
+  const contextualExpectedMessage: Array<string> = [];
+
+  const typenameCap = typename.charAt(0).toUpperCase() + typename.slice(1);
+  const typenameCapPlural = typenameCap + 's';
+  const installerName = `disallow${typenameCap}s`;
+
+  function handleMessage(message: string): void {
+    const index = expectedMessages.findIndex(expected =>
+      message.startsWith(expected),
+    );
+    const optionalIndex = optionalMessages.findIndex(expected =>
+      message.startsWith(expected),
+    );
+    if (
+      contextualExpectedMessage.length > 0 &&
+      message.startsWith(contextualExpectedMessage[0])
+    ) {
+      contextualExpectedMessage.shift();
+    } else if (index >= 0) {
+      expectedMessages.splice(index, 1);
+    } else if (optionalIndex >= 0) {
+      optionalMessages.splice(optionalIndex, 1);
+    } else {
+      // log to console in case the error gets swallowed somewhere
+      originalConsoleError(`Unexpected ${typenameCap}: ` + message);
+      throw new Error(`${typenameCap}: ` + message);
+    }
+  }
+
+  function disallowMessages(): void {
+    if (installed) {
+      throw new Error(`${installerName} should be called only once.`);
+    }
+    installed = true;
+    setUpMock(handleMessage);
+
+    afterEach(() => {
+      optionalMessages.length = 0;
+      contextualExpectedMessage.length = 0;
+      if (expectedMessages.length > 0) {
+        const error = new Error(
+          `Some ${expectedMessages.length} expected ${typename}s where not triggered:\n\n` +
+            Array.from(expectedMessages, message => ` * ${message}`).join(
+              '\n',
+            ) +
+            '\n',
+        );
+        expectedMessages.length = 0;
+        throw error;
+      }
+    });
+  }
+
+  function expectMessageWillFire(
+    message: string,
+    options?: WillFireOptions,
+  ): void {
+    if (!installed) {
+      throw new Error(
+        `${installerName} needs to be called before expect${typenameCapPlural}WillFire`,
+      );
+    }
+    const optional = options?.optional === true; // avoid "sketchy null check"
+    for (let i = 0; i < (options?.count ?? 1); i++) {
+      (optional ? optionalMessages : expectedMessages).push(message);
+    }
+  }
+
+  function expectMessage<T>(message: string, fn: () => T): T {
+    return expectMessageMany([message], fn);
+  }
+
+  function expectMessageMany<T>(messages: Array<string>, fn: () => T): T {
+    if (contextualExpectedMessage.length > 0) {
+      throw new Error(`Cannot nest ${expectFunctionName}() calls.`);
+    }
+    contextualExpectedMessage.push(...messages);
+    const result = fn();
+    if (contextualExpectedMessage.length > 0) {
+      const notFired = contextualExpectedMessage.toString();
+      contextualExpectedMessage.length = 0;
+      throw new Error(`Expected ${typename} in callback: ${notFired}`);
+    }
+    return result;
+  }
+
+  return {
+    disallowMessages,
+    expectMessageWillFire,
+    expectMessage,
+    expectMessageMany,
+  };
+}
+
+module.exports = {
+  createConsoleInterceptionSystem,
+};

package/consoleWarning.js.flow

@@ -0,0 +1,70 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+/* global jest */
+
+import type {WillFireOptions} from './consoleErrorsAndWarnings';
+
+const {createConsoleInterceptionSystem} = require('./consoleErrorsAndWarnings');
+
+const consoleWarningsSystem = createConsoleInterceptionSystem(
+  'warning',
+  'expectConsoleWarning',
+  impl => {
+    jest.spyOn(console, 'warn').mockImplementation(impl);
+  },
+);
+
+/**
+ * Mocks console.warn so that warnings printed to the console are instead thrown.
+ * Any expected warnings need to be explicitly expected with `expectConsoleWarningWillFire(message)`.
+ *
+ * NOTE: This should be called on top of a test file. The test should NOT
+ *       use `jest.resetModules()` or manually mock `console`.
+ */
+function disallowConsoleWarnings(): void {
+  consoleWarningsSystem.disallowMessages();
+}
+
+/**
+ * Expect a warning with the given message. If the message isn't fired in the
+ * current test, the test will fail.
+ */
+function expectConsoleWarningWillFire(
+  message: string,
+  options?: WillFireOptions,
+): void {
+  consoleWarningsSystem.expectMessageWillFire(message, options);
+}
+
+/**
+ * Expect the callback `fn` to print a warning with the message, and otherwise fail.
+ */
+function expectConsoleWarning<T>(message: string, fn: () => T): T {
+  return consoleWarningsSystem.expectMessage(message, fn);
+}
+
+/**
+ * Expect the callback `fn` to trigger all console warnings (in sequence),
+ * and otherwise fail.
+ */
+function expectConsoleWarningsMany<T>(messages: Array<string>, fn: () => T): T {
+  return consoleWarningsSystem.expectMessageMany(messages, fn);
+}
+
+module.exports = {
+  disallowConsoleWarnings,
+  expectConsoleWarningWillFire,
+  expectConsoleWarning,
+  expectConsoleWarningsMany,
+};

package/describeWithFeatureFlags.js.flow

@@ -13,8 +13,6 @@
  * Beware that calling jest.resetModules() within the suite may break this.
  */
 
-// flowlint ambiguous-object-type:error
-
 'use strict';
 
 import type {FeatureFlags} from '../relay-runtime/util/RelayFeatureFlags';

package/getOutputForFixture.js.flow

@@ -8,8 +8,6 @@
  * @format
  */
 
-// flowlint ambiguous-object-type:error
-
 'use strict';
 
 function getOutputForFixture(

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Relay v13.1.1
+ * Relay v14.1.0
  *
  * Copyright (c) Meta Platforms, Inc. and affiliates.
  *

package/index.js.flow

@@ -8,10 +8,20 @@
  * @format
  */
 
-// flowlint ambiguous-object-type:error
-
 'use strict';
 
+const {
+  disallowConsoleErrors,
+  expectConsoleError,
+  expectConsoleErrorsMany,
+  expectConsoleErrorWillFire,
+} = require('./consoleError');
+const {
+  disallowConsoleWarnings,
+  expectConsoleWarning,
+  expectConsoleWarningsMany,
+  expectConsoleWarningWillFire,
+} = require('./consoleWarning');
 const describeWithFeatureFlags = require('./describeWithFeatureFlags');
 const {
   FIXTURE_TAG,
@@ -20,6 +30,7 @@ const {
 const Matchers = require('./Matchers');
 const printAST = require('./printAST');
 const simpleClone = require('./simpleClone');
+const trackRetentionForEnvironment = require('./trackRetentionForEnvironment');
 const {
   disallowWarnings,
   expectToWarn,
@@ -50,14 +61,23 @@ module.exports = {
   cannotReadPropertyOfUndefined__DEPRECATED,
   createMockEnvironment,
   describeWithFeatureFlags,
+  disallowConsoleErrors,
+  disallowConsoleWarnings,
+  disallowWarnings,
+  expectConsoleError,
+  expectConsoleErrorsMany,
+  expectConsoleErrorWillFire,
+  expectConsoleWarningWillFire,
+  expectConsoleWarning,
+  expectConsoleWarningsMany,
   expectToWarn,
   expectToWarnMany,
   expectWarningWillFire,
-  disallowWarnings,
   FIXTURE_TAG,
   generateTestsFromFixtures,
   matchers: Matchers,
   printAST,
   simpleClone,
+  trackRetentionForEnvironment,
   unwrapContainer,
 };

package/lib/consoleError.js

@@ -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.
+ *
+ * @emails oncall+relay
+ * 
+ * @format
+ */
+'use strict';
+/* global jest */
+
+var _require = require('./consoleErrorsAndWarnings'),
+    createConsoleInterceptionSystem = _require.createConsoleInterceptionSystem;
+
+var consoleErrorsSystem = createConsoleInterceptionSystem('error', 'expectConsoleError', function (impl) {
+  jest.spyOn(console, 'error').mockImplementation(impl);
+});
+/**
+ * Mocks console.error so that errors printed to the console are instead thrown.
+ * Any expected errors need to be explicitly expected with `expectConsoleErrorWillFire(message)`.
+ *
+ * NOTE: This should be called on top of a test file. The test should NOT
+ *       use `jest.resetModules()` or manually mock `console`.
+ */
+
+function disallowConsoleErrors() {
+  consoleErrorsSystem.disallowMessages();
+}
+/**
+ * Expect an error with the given message. If the message isn't fired in the
+ * current test, the test will fail.
+ */
+
+
+function expectConsoleErrorWillFire(message, options) {
+  consoleErrorsSystem.expectMessageWillFire(message, options);
+}
+/**
+ * Expect the callback `fn` to print an error with the message, and otherwise fail.
+ */
+
+
+function expectConsoleError(message, fn) {
+  return consoleErrorsSystem.expectMessage(message, fn);
+}
+/**
+ * Expect the callback `fn` to trigger all console errors (in sequence),
+ * and otherwise fail.
+ */
+
+
+function expectConsoleErrorsMany(messages, fn) {
+  return consoleErrorsSystem.expectMessageMany(messages, fn);
+}
+
+module.exports = {
+  disallowConsoleErrors: disallowConsoleErrors,
+  expectConsoleErrorWillFire: expectConsoleErrorWillFire,
+  expectConsoleError: expectConsoleError,
+  expectConsoleErrorsMany: expectConsoleErrorsMany
+};

package/lib/consoleErrorsAndWarnings.js

@@ -0,0 +1,116 @@
+/**
+ * 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.
+ *
+ * @emails oncall+relay
+ * 
+ * @format
+ */
+'use strict';
+/* global afterEach */
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var originalConsoleError = console.error;
+
+function createConsoleInterceptionSystem(typename, expectFunctionName, setUpMock) {
+  var installed = false;
+  var expectedMessages = [];
+  var optionalMessages = [];
+  var contextualExpectedMessage = [];
+  var typenameCap = typename.charAt(0).toUpperCase() + typename.slice(1);
+  var typenameCapPlural = typenameCap + 's';
+  var installerName = "disallow".concat(typenameCap, "s");
+
+  function handleMessage(message) {
+    var index = expectedMessages.findIndex(function (expected) {
+      return message.startsWith(expected);
+    });
+    var optionalIndex = optionalMessages.findIndex(function (expected) {
+      return message.startsWith(expected);
+    });
+
+    if (contextualExpectedMessage.length > 0 && message.startsWith(contextualExpectedMessage[0])) {
+      contextualExpectedMessage.shift();
+    } else if (index >= 0) {
+      expectedMessages.splice(index, 1);
+    } else if (optionalIndex >= 0) {
+      optionalMessages.splice(optionalIndex, 1);
+    } else {
+      // log to console in case the error gets swallowed somewhere
+      originalConsoleError("Unexpected ".concat(typenameCap, ": ") + message);
+      throw new Error("".concat(typenameCap, ": ") + message);
+    }
+  }
+
+  function disallowMessages() {
+    if (installed) {
+      throw new Error("".concat(installerName, " should be called only once."));
+    }
+
+    installed = true;
+    setUpMock(handleMessage);
+    afterEach(function () {
+      optionalMessages.length = 0;
+      contextualExpectedMessage.length = 0;
+
+      if (expectedMessages.length > 0) {
+        var error = new Error("Some ".concat(expectedMessages.length, " expected ").concat(typename, "s where not triggered:\n\n") + Array.from(expectedMessages, function (message) {
+          return " * ".concat(message);
+        }).join('\n') + '\n');
+        expectedMessages.length = 0;
+        throw error;
+      }
+    });
+  }
+
+  function expectMessageWillFire(message, options) {
+    if (!installed) {
+      throw new Error("".concat(installerName, " needs to be called before expect").concat(typenameCapPlural, "WillFire"));
+    }
+
+    var optional = (options === null || options === void 0 ? void 0 : options.optional) === true; // avoid "sketchy null check"
+
+    for (var i = 0; i < ((_options$count = options === null || options === void 0 ? void 0 : options.count) !== null && _options$count !== void 0 ? _options$count : 1); i++) {
+      var _options$count;
+
+      (optional ? optionalMessages : expectedMessages).push(message);
+    }
+  }
+
+  function expectMessage(message, fn) {
+    return expectMessageMany([message], fn);
+  }
+
+  function expectMessageMany(messages, fn) {
+    if (contextualExpectedMessage.length > 0) {
+      throw new Error("Cannot nest ".concat(expectFunctionName, "() calls."));
+    }
+
+    contextualExpectedMessage.push.apply(contextualExpectedMessage, (0, _toConsumableArray2["default"])(messages));
+    var result = fn();
+
+    if (contextualExpectedMessage.length > 0) {
+      var notFired = contextualExpectedMessage.toString();
+      contextualExpectedMessage.length = 0;
+      throw new Error("Expected ".concat(typename, " in callback: ").concat(notFired));
+    }
+
+    return result;
+  }
+
+  return {
+    disallowMessages: disallowMessages,
+    expectMessageWillFire: expectMessageWillFire,
+    expectMessage: expectMessage,
+    expectMessageMany: expectMessageMany
+  };
+}
+
+module.exports = {
+  createConsoleInterceptionSystem: createConsoleInterceptionSystem
+};

package/lib/consoleWarning.js

@@ -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.
+ *
+ * @emails oncall+relay
+ * 
+ * @format
+ */
+'use strict';
+/* global jest */
+
+var _require = require('./consoleErrorsAndWarnings'),
+    createConsoleInterceptionSystem = _require.createConsoleInterceptionSystem;
+
+var consoleWarningsSystem = createConsoleInterceptionSystem('warning', 'expectConsoleWarning', function (impl) {
+  jest.spyOn(console, 'warn').mockImplementation(impl);
+});
+/**
+ * Mocks console.warn so that warnings printed to the console are instead thrown.
+ * Any expected warnings need to be explicitly expected with `expectConsoleWarningWillFire(message)`.
+ *
+ * NOTE: This should be called on top of a test file. The test should NOT
+ *       use `jest.resetModules()` or manually mock `console`.
+ */
+
+function disallowConsoleWarnings() {
+  consoleWarningsSystem.disallowMessages();
+}
+/**
+ * Expect a warning with the given message. If the message isn't fired in the
+ * current test, the test will fail.
+ */
+
+
+function expectConsoleWarningWillFire(message, options) {
+  consoleWarningsSystem.expectMessageWillFire(message, options);
+}
+/**
+ * Expect the callback `fn` to print a warning with the message, and otherwise fail.
+ */
+
+
+function expectConsoleWarning(message, fn) {
+  return consoleWarningsSystem.expectMessage(message, fn);
+}
+/**
+ * Expect the callback `fn` to trigger all console warnings (in sequence),
+ * and otherwise fail.
+ */
+
+
+function expectConsoleWarningsMany(messages, fn) {
+  return consoleWarningsSystem.expectMessageMany(messages, fn);
+}
+
+module.exports = {
+  disallowConsoleWarnings: disallowConsoleWarnings,
+  expectConsoleWarningWillFire: expectConsoleWarningWillFire,
+  expectConsoleWarning: expectConsoleWarning,
+  expectConsoleWarningsMany: expectConsoleWarningsMany
+};

package/lib/describeWithFeatureFlags.js

@@ -12,10 +12,9 @@
  * Run a test suite under multiple sets of feature flags.
  * Beware that calling jest.resetModules() within the suite may break this.
  */
-// flowlint ambiguous-object-type:error
 'use strict';
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
 
 var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
 

package/lib/generateTestsFromFixtures.js

@@ -8,7 +8,7 @@
  */
 'use strict';
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
 
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
 

package/lib/getOutputForFixture.js

@@ -7,7 +7,6 @@
  * 
  * @format
  */
-// flowlint ambiguous-object-type:error
 'use strict';
 
 function getOutputForFixture(input, operation, file) {