claude-autopm 3.1.1 → 3.2.0

package/packages/plugin-devops/node_modules/jest-circus/build/legacy-code-todo-rewrite/jestAdapterInit.js

@@ -1,240 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-exports.runAndTransformResultsToJestFormat = exports.initialize = void 0;
-var _expect = require('@jest/expect');
-var _testResult = require('@jest/test-result');
-var _jestMessageUtil = require('jest-message-util');
-var _jestSnapshot = require('jest-snapshot');
-var _ = _interopRequireDefault(require('..'));
-var _run = _interopRequireDefault(require('../run'));
-var _state = require('../state');
-var _testCaseReportHandler = _interopRequireDefault(
-  require('../testCaseReportHandler')
-);
-var _utils = require('../utils');
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : {default: obj};
-}
-/**
- * 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.
- */
-
-const initialize = async ({
-  config,
-  environment,
-  globalConfig,
-  localRequire,
-  parentProcess,
-  sendMessageToJest,
-  setGlobalsForRuntime,
-  testPath
-}) => {
-  if (globalConfig.testTimeout) {
-    (0, _state.getState)().testTimeout = globalConfig.testTimeout;
-  }
-  (0, _state.getState)().maxConcurrency = globalConfig.maxConcurrency;
-  (0, _state.getState)().randomize = globalConfig.randomize;
-  (0, _state.getState)().seed = globalConfig.seed;
-
-  // @ts-expect-error: missing `concurrent` which is added later
-  const globalsObject = {
-    ..._.default,
-    fdescribe: _.default.describe.only,
-    fit: _.default.it.only,
-    xdescribe: _.default.describe.skip,
-    xit: _.default.it.skip,
-    xtest: _.default.it.skip
-  };
-  (0, _state.addEventHandler)(eventHandler);
-  if (environment.handleTestEvent) {
-    (0, _state.addEventHandler)(environment.handleTestEvent.bind(environment));
-  }
-  _expect.jestExpect.setState({
-    expand: globalConfig.expand
-  });
-  const runtimeGlobals = {
-    ...globalsObject,
-    expect: _expect.jestExpect
-  };
-  setGlobalsForRuntime(runtimeGlobals);
-  if (config.injectGlobals) {
-    Object.assign(environment.global, runtimeGlobals);
-  }
-  await (0, _state.dispatch)({
-    name: 'setup',
-    parentProcess,
-    runtimeGlobals,
-    testNamePattern: globalConfig.testNamePattern
-  });
-  if (config.testLocationInResults) {
-    await (0, _state.dispatch)({
-      name: 'include_test_location_in_result'
-    });
-  }
-
-  // Jest tests snapshotSerializers in order preceding built-in serializers.
-  // Therefore, add in reverse because the last added is the first tested.
-  config.snapshotSerializers
-    .concat()
-    .reverse()
-    .forEach(path => (0, _jestSnapshot.addSerializer)(localRequire(path)));
-  const snapshotResolver = await (0, _jestSnapshot.buildSnapshotResolver)(
-    config,
-    localRequire
-  );
-  const snapshotPath = snapshotResolver.resolveSnapshotPath(testPath);
-  const snapshotState = new _jestSnapshot.SnapshotState(snapshotPath, {
-    expand: globalConfig.expand,
-    prettierPath: config.prettierPath,
-    rootDir: config.rootDir,
-    snapshotFormat: config.snapshotFormat,
-    updateSnapshot: globalConfig.updateSnapshot
-  });
-  _expect.jestExpect.setState({
-    snapshotState,
-    testPath
-  });
-  (0, _state.addEventHandler)(handleSnapshotStateAfterRetry(snapshotState));
-  if (sendMessageToJest) {
-    (0, _state.addEventHandler)(
-      (0, _testCaseReportHandler.default)(testPath, sendMessageToJest)
-    );
-  }
-
-  // Return it back to the outer scope (test runner outside the VM).
-  return {
-    globals: globalsObject,
-    snapshotState
-  };
-};
-exports.initialize = initialize;
-const runAndTransformResultsToJestFormat = async ({
-  config,
-  globalConfig,
-  testPath
-}) => {
-  const runResult = await (0, _run.default)();
-  let numFailingTests = 0;
-  let numPassingTests = 0;
-  let numPendingTests = 0;
-  let numTodoTests = 0;
-  const assertionResults = runResult.testResults.map(testResult => {
-    let status;
-    if (testResult.status === 'skip') {
-      status = 'pending';
-      numPendingTests += 1;
-    } else if (testResult.status === 'todo') {
-      status = 'todo';
-      numTodoTests += 1;
-    } else if (testResult.errors.length) {
-      status = 'failed';
-      numFailingTests += 1;
-    } else {
-      status = 'passed';
-      numPassingTests += 1;
-    }
-    const ancestorTitles = testResult.testPath.filter(
-      name => name !== _state.ROOT_DESCRIBE_BLOCK_NAME
-    );
-    const title = ancestorTitles.pop();
-    return {
-      ancestorTitles,
-      duration: testResult.duration,
-      failureDetails: testResult.errorsDetailed,
-      failureMessages: testResult.errors,
-      fullName: title
-        ? ancestorTitles.concat(title).join(' ')
-        : ancestorTitles.join(' '),
-      invocations: testResult.invocations,
-      location: testResult.location,
-      numPassingAsserts: testResult.numPassingAsserts,
-      retryReasons: testResult.retryReasons,
-      status,
-      title: testResult.testPath[testResult.testPath.length - 1]
-    };
-  });
-  let failureMessage = (0, _jestMessageUtil.formatResultsErrors)(
-    assertionResults,
-    config,
-    globalConfig,
-    testPath
-  );
-  let testExecError;
-  if (runResult.unhandledErrors.length) {
-    testExecError = {
-      message: '',
-      stack: runResult.unhandledErrors.join('\n')
-    };
-    failureMessage = `${failureMessage || ''}\n\n${runResult.unhandledErrors
-      .map(err =>
-        (0, _jestMessageUtil.formatExecError)(err, config, globalConfig)
-      )
-      .join('\n')}`;
-  }
-  await (0, _state.dispatch)({
-    name: 'teardown'
-  });
-  return {
-    ...(0, _testResult.createEmptyTestResult)(),
-    console: undefined,
-    displayName: config.displayName,
-    failureMessage,
-    numFailingTests,
-    numPassingTests,
-    numPendingTests,
-    numTodoTests,
-    testExecError,
-    testFilePath: testPath,
-    testResults: assertionResults
-  };
-};
-exports.runAndTransformResultsToJestFormat = runAndTransformResultsToJestFormat;
-const handleSnapshotStateAfterRetry = snapshotState => event => {
-  switch (event.name) {
-    case 'test_retry': {
-      // Clear any snapshot data that occurred in previous test run
-      snapshotState.clear();
-    }
-  }
-};
-const eventHandler = async event => {
-  switch (event.name) {
-    case 'test_start': {
-      _expect.jestExpect.setState({
-        currentTestName: (0, _utils.getTestID)(event.test)
-      });
-      break;
-    }
-    case 'test_done': {
-      event.test.numPassingAsserts =
-        _expect.jestExpect.getState().numPassingAsserts;
-      _addSuppressedErrors(event.test);
-      _addExpectedAssertionErrors(event.test);
-      break;
-    }
-  }
-};
-const _addExpectedAssertionErrors = test => {
-  const failures = _expect.jestExpect.extractExpectedAssertionsErrors();
-  const errors = failures.map(failure => failure.error);
-  test.errors = test.errors.concat(errors);
-};
-
-// Get suppressed errors from ``jest-matchers`` that weren't throw during
-// test execution and add them to the test result, potentially failing
-// a passing test.
-const _addSuppressedErrors = test => {
-  const {suppressedErrors} = _expect.jestExpect.getState();
-  _expect.jestExpect.setState({
-    suppressedErrors: []
-  });
-  if (suppressedErrors.length) {
-    test.errors = test.errors.concat(suppressedErrors);
-  }
-};

package/packages/plugin-devops/node_modules/jest-circus/build/run.js

@@ -1,350 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-exports.default = void 0;
-var _async_hooks = require('async_hooks');
-var _pLimit = _interopRequireDefault(require('p-limit'));
-var _expect = require('@jest/expect');
-var _jestUtil = require('jest-util');
-var _shuffleArray = _interopRequireWildcard(require('./shuffleArray'));
-var _state = require('./state');
-var _types = require('./types');
-var _utils = require('./utils');
-function _getRequireWildcardCache(nodeInterop) {
-  if (typeof WeakMap !== 'function') return null;
-  var cacheBabelInterop = new WeakMap();
-  var cacheNodeInterop = new WeakMap();
-  return (_getRequireWildcardCache = function (nodeInterop) {
-    return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
-  })(nodeInterop);
-}
-function _interopRequireWildcard(obj, nodeInterop) {
-  if (!nodeInterop && obj && obj.__esModule) {
-    return obj;
-  }
-  if (obj === null || (typeof obj !== 'object' && typeof obj !== 'function')) {
-    return {default: obj};
-  }
-  var cache = _getRequireWildcardCache(nodeInterop);
-  if (cache && cache.has(obj)) {
-    return cache.get(obj);
-  }
-  var newObj = {};
-  var hasPropertyDescriptor =
-    Object.defineProperty && Object.getOwnPropertyDescriptor;
-  for (var key in obj) {
-    if (key !== 'default' && Object.prototype.hasOwnProperty.call(obj, key)) {
-      var desc = hasPropertyDescriptor
-        ? Object.getOwnPropertyDescriptor(obj, key)
-        : null;
-      if (desc && (desc.get || desc.set)) {
-        Object.defineProperty(newObj, key, desc);
-      } else {
-        newObj[key] = obj[key];
-      }
-    }
-  }
-  newObj.default = obj;
-  if (cache) {
-    cache.set(obj, newObj);
-  }
-  return newObj;
-}
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : {default: obj};
-}
-/**
- * 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.
- */
-
-const run = async () => {
-  const {rootDescribeBlock, seed, randomize} = (0, _state.getState)();
-  const rng = randomize ? (0, _shuffleArray.rngBuilder)(seed) : undefined;
-  await (0, _state.dispatch)({
-    name: 'run_start'
-  });
-  await _runTestsForDescribeBlock(rootDescribeBlock, rng, true);
-  await (0, _state.dispatch)({
-    name: 'run_finish'
-  });
-  return (0, _utils.makeRunResult)(
-    (0, _state.getState)().rootDescribeBlock,
-    (0, _state.getState)().unhandledErrors
-  );
-};
-const _runTestsForDescribeBlock = async (
-  describeBlock,
-  rng,
-  isRootBlock = false
-) => {
-  await (0, _state.dispatch)({
-    describeBlock,
-    name: 'run_describe_start'
-  });
-  const {beforeAll, afterAll} = (0, _utils.getAllHooksForDescribe)(
-    describeBlock
-  );
-  const isSkipped = describeBlock.mode === 'skip';
-  if (!isSkipped) {
-    for (const hook of beforeAll) {
-      await _callCircusHook({
-        describeBlock,
-        hook
-      });
-    }
-  }
-  if (isRootBlock) {
-    const concurrentTests = collectConcurrentTests(describeBlock);
-    if (concurrentTests.length > 0) {
-      startTestsConcurrently(concurrentTests);
-    }
-  }
-
-  // Tests that fail and are retried we run after other tests
-  // eslint-disable-next-line no-restricted-globals
-  const retryTimes = parseInt(global[_types.RETRY_TIMES], 10) || 0;
-  const deferredRetryTests = [];
-  if (rng) {
-    describeBlock.children = (0, _shuffleArray.default)(
-      describeBlock.children,
-      rng
-    );
-  }
-  for (const child of describeBlock.children) {
-    switch (child.type) {
-      case 'describeBlock': {
-        await _runTestsForDescribeBlock(child, rng);
-        break;
-      }
-      case 'test': {
-        const hasErrorsBeforeTestRun = child.errors.length > 0;
-        await _runTest(child, isSkipped);
-        if (
-          hasErrorsBeforeTestRun === false &&
-          retryTimes > 0 &&
-          child.errors.length > 0
-        ) {
-          deferredRetryTests.push(child);
-        }
-        break;
-      }
-    }
-  }
-
-  // Re-run failed tests n-times if configured
-  for (const test of deferredRetryTests) {
-    let numRetriesAvailable = retryTimes;
-    while (numRetriesAvailable > 0 && test.errors.length > 0) {
-      // Clear errors so retries occur
-      await (0, _state.dispatch)({
-        name: 'test_retry',
-        test
-      });
-      await _runTest(test, isSkipped);
-      numRetriesAvailable--;
-    }
-  }
-  if (!isSkipped) {
-    for (const hook of afterAll) {
-      await _callCircusHook({
-        describeBlock,
-        hook
-      });
-    }
-  }
-  await (0, _state.dispatch)({
-    describeBlock,
-    name: 'run_describe_finish'
-  });
-};
-function collectConcurrentTests(describeBlock) {
-  if (describeBlock.mode === 'skip') {
-    return [];
-  }
-  const {hasFocusedTests, testNamePattern} = (0, _state.getState)();
-  return describeBlock.children.flatMap(child => {
-    switch (child.type) {
-      case 'describeBlock':
-        return collectConcurrentTests(child);
-      case 'test':
-        const skip =
-          !child.concurrent ||
-          child.mode === 'skip' ||
-          (hasFocusedTests && child.mode !== 'only') ||
-          (testNamePattern &&
-            !testNamePattern.test((0, _utils.getTestID)(child)));
-        return skip ? [] : [child];
-    }
-  });
-}
-function startTestsConcurrently(concurrentTests) {
-  const mutex = (0, _pLimit.default)((0, _state.getState)().maxConcurrency);
-  const testNameStorage = new _async_hooks.AsyncLocalStorage();
-  _expect.jestExpect.setState({
-    currentConcurrentTestName: () => testNameStorage.getStore()
-  });
-  for (const test of concurrentTests) {
-    try {
-      const testFn = test.fn;
-      const promise = mutex(() =>
-        testNameStorage.run((0, _utils.getTestID)(test), testFn)
-      );
-      // Avoid triggering the uncaught promise rejection handler in case the
-      // test fails before being awaited on.
-      // eslint-disable-next-line @typescript-eslint/no-empty-function
-      promise.catch(() => {});
-      test.fn = () => promise;
-    } catch (err) {
-      test.fn = () => {
-        throw err;
-      };
-    }
-  }
-}
-const _runTest = async (test, parentSkipped) => {
-  await (0, _state.dispatch)({
-    name: 'test_start',
-    test
-  });
-  const testContext = Object.create(null);
-  const {hasFocusedTests, testNamePattern} = (0, _state.getState)();
-  const isSkipped =
-    parentSkipped ||
-    test.mode === 'skip' ||
-    (hasFocusedTests && test.mode === undefined) ||
-    (testNamePattern && !testNamePattern.test((0, _utils.getTestID)(test)));
-  if (isSkipped) {
-    await (0, _state.dispatch)({
-      name: 'test_skip',
-      test
-    });
-    return;
-  }
-  if (test.mode === 'todo') {
-    await (0, _state.dispatch)({
-      name: 'test_todo',
-      test
-    });
-    return;
-  }
-  await (0, _state.dispatch)({
-    name: 'test_started',
-    test
-  });
-  const {afterEach, beforeEach} = (0, _utils.getEachHooksForTest)(test);
-  for (const hook of beforeEach) {
-    if (test.errors.length) {
-      // If any of the before hooks failed already, we don't run any
-      // hooks after that.
-      break;
-    }
-    await _callCircusHook({
-      hook,
-      test,
-      testContext
-    });
-  }
-  await _callCircusTest(test, testContext);
-  for (const hook of afterEach) {
-    await _callCircusHook({
-      hook,
-      test,
-      testContext
-    });
-  }
-
-  // `afterAll` hooks should not affect test status (pass or fail), because if
-  // we had a global `afterAll` hook it would block all existing tests until
-  // this hook is executed. So we dispatch `test_done` right away.
-  await (0, _state.dispatch)({
-    name: 'test_done',
-    test
-  });
-};
-const _callCircusHook = async ({
-  hook,
-  test,
-  describeBlock,
-  testContext = {}
-}) => {
-  await (0, _state.dispatch)({
-    hook,
-    name: 'hook_start'
-  });
-  const timeout = hook.timeout || (0, _state.getState)().testTimeout;
-  try {
-    await (0, _utils.callAsyncCircusFn)(hook, testContext, {
-      isHook: true,
-      timeout
-    });
-    await (0, _state.dispatch)({
-      describeBlock,
-      hook,
-      name: 'hook_success',
-      test
-    });
-  } catch (error) {
-    await (0, _state.dispatch)({
-      describeBlock,
-      error,
-      hook,
-      name: 'hook_failure',
-      test
-    });
-  }
-};
-const _callCircusTest = async (test, testContext) => {
-  await (0, _state.dispatch)({
-    name: 'test_fn_start',
-    test
-  });
-  const timeout = test.timeout || (0, _state.getState)().testTimeout;
-  (0, _jestUtil.invariant)(
-    test.fn,
-    "Tests with no 'fn' should have 'mode' set to 'skipped'"
-  );
-  if (test.errors.length) {
-    return; // We don't run the test if there's already an error in before hooks.
-  }
-
-  try {
-    await (0, _utils.callAsyncCircusFn)(test, testContext, {
-      isHook: false,
-      timeout
-    });
-    if (test.failing) {
-      test.asyncError.message =
-        'Failing test passed even though it was supposed to fail. Remove `.failing` to remove error.';
-      await (0, _state.dispatch)({
-        error: test.asyncError,
-        name: 'test_fn_failure',
-        test
-      });
-    } else {
-      await (0, _state.dispatch)({
-        name: 'test_fn_success',
-        test
-      });
-    }
-  } catch (error) {
-    if (test.failing) {
-      await (0, _state.dispatch)({
-        name: 'test_fn_success',
-        test
-      });
-    } else {
-      await (0, _state.dispatch)({
-        error,
-        name: 'test_fn_failure',
-        test
-      });
-    }
-  }
-};
-var _default = run;
-exports.default = _default;

package/packages/plugin-devops/node_modules/jest-circus/build/shuffleArray.js

@@ -1,41 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-exports.default = shuffleArray;
-exports.rngBuilder = void 0;
-var _pureRand = require('pure-rand');
-/**
- * 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.
- */
-
-// Generates [from, to] inclusive
-
-const rngBuilder = seed => {
-  const gen = (0, _pureRand.xoroshiro128plus)(seed);
-  return {
-    next: (from, to) =>
-      (0, _pureRand.unsafeUniformIntDistribution)(from, to, gen)
-  };
-};
-
-// Fisher-Yates shuffle
-// This is performed in-place
-exports.rngBuilder = rngBuilder;
-function shuffleArray(array, random) {
-  const length = array.length;
-  if (length === 0) {
-    return [];
-  }
-  for (let i = 0; i < length; i++) {
-    const n = random.next(i, length - 1);
-    const value = array[i];
-    array[i] = array[n];
-    array[n] = value;
-  }
-  return array;
-}

package/packages/plugin-devops/node_modules/jest-circus/build/state.js

@@ -1,80 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', {
-  value: true
-});
-exports.setState =
-  exports.resetState =
-  exports.getState =
-  exports.dispatchSync =
-  exports.dispatch =
-  exports.addEventHandler =
-  exports.ROOT_DESCRIBE_BLOCK_NAME =
-    void 0;
-var _eventHandler = _interopRequireDefault(require('./eventHandler'));
-var _formatNodeAssertErrors = _interopRequireDefault(
-  require('./formatNodeAssertErrors')
-);
-var _types = require('./types');
-var _utils = require('./utils');
-function _interopRequireDefault(obj) {
-  return obj && obj.__esModule ? obj : {default: obj};
-}
-/**
- * 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.
- */
-
-const eventHandlers = [_eventHandler.default, _formatNodeAssertErrors.default];
-const ROOT_DESCRIBE_BLOCK_NAME = 'ROOT_DESCRIBE_BLOCK';
-exports.ROOT_DESCRIBE_BLOCK_NAME = ROOT_DESCRIBE_BLOCK_NAME;
-const createState = () => {
-  const ROOT_DESCRIBE_BLOCK = (0, _utils.makeDescribe)(
-    ROOT_DESCRIBE_BLOCK_NAME
-  );
-  return {
-    currentDescribeBlock: ROOT_DESCRIBE_BLOCK,
-    currentlyRunningTest: null,
-    expand: undefined,
-    hasFocusedTests: false,
-    hasStarted: false,
-    includeTestLocationInResult: false,
-    maxConcurrency: 5,
-    parentProcess: null,
-    rootDescribeBlock: ROOT_DESCRIBE_BLOCK,
-    seed: 0,
-    testNamePattern: null,
-    testTimeout: 5000,
-    unhandledErrors: []
-  };
-};
-
-/* eslint-disable no-restricted-globals */
-const resetState = () => {
-  global[_types.STATE_SYM] = createState();
-};
-exports.resetState = resetState;
-resetState();
-const getState = () => global[_types.STATE_SYM];
-exports.getState = getState;
-const setState = state => (global[_types.STATE_SYM] = state);
-/* eslint-enable */
-exports.setState = setState;
-const dispatch = async event => {
-  for (const handler of eventHandlers) {
-    await handler(event, getState());
-  }
-};
-exports.dispatch = dispatch;
-const dispatchSync = event => {
-  for (const handler of eventHandlers) {
-    handler(event, getState());
-  }
-};
-exports.dispatchSync = dispatchSync;
-const addEventHandler = handler => {
-  eventHandlers.push(handler);
-};
-exports.addEventHandler = addEventHandler;