mirror of
https://github.com/cachix/install-nix-action.git
synced 2025-06-08 18:04:29 +00:00
v5
This commit is contained in:
Domen Kožar
parent
d1407282e6
commit
08403cd828
6774 changed files with 1602535 additions and 1 deletions
134
node_modules/jest-mock/build/index.d.ts
generated
vendored
Normal file
134
node_modules/jest-mock/build/index.d.ts
generated
vendored
Normal file
|
|
@ -0,0 +1,134 @@
|
|||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
/// <reference types="node" />
|
||||
declare type Global = NodeJS.Global;
|
||||
declare namespace JestMock {
|
||||
type ModuleMocker = ModuleMockerClass;
|
||||
type MockFunctionMetadataType = 'object' | 'array' | 'regexp' | 'function' | 'constant' | 'collection' | 'null' | 'undefined';
|
||||
type MockFunctionMetadata<T, Y extends Array<unknown>, Type = MockFunctionMetadataType> = {
|
||||
ref?: number;
|
||||
members?: Record<string, MockFunctionMetadata<T, Y>>;
|
||||
mockImpl?: (...args: Y) => T;
|
||||
name?: string;
|
||||
refID?: number;
|
||||
type?: Type;
|
||||
value?: T;
|
||||
length?: number;
|
||||
};
|
||||
}
|
||||
/**
|
||||
* Possible types of a MockFunctionResult.
|
||||
* 'return': The call completed by returning normally.
|
||||
* 'throw': The call completed by throwing a value.
|
||||
* 'incomplete': The call has not completed yet. This is possible if you read
|
||||
* the mock function result from within the mock function itself
|
||||
* (or a function called by the mock function).
|
||||
*/
|
||||
declare type MockFunctionResultType = 'return' | 'throw' | 'incomplete';
|
||||
/**
|
||||
* Represents the result of a single call to a mock function.
|
||||
*/
|
||||
declare type MockFunctionResult = {
|
||||
/**
|
||||
* Indicates how the call completed.
|
||||
*/
|
||||
type: MockFunctionResultType;
|
||||
/**
|
||||
* The value that was either thrown or returned by the function.
|
||||
* Undefined when type === 'incomplete'.
|
||||
*/
|
||||
value: unknown;
|
||||
};
|
||||
declare type MockFunctionState<T, Y extends Array<unknown>> = {
|
||||
calls: Array<Y>;
|
||||
instances: Array<T>;
|
||||
invocationCallOrder: Array<number>;
|
||||
/**
|
||||
* List of results of calls to the mock function.
|
||||
*/
|
||||
results: Array<MockFunctionResult>;
|
||||
};
|
||||
declare type NonFunctionPropertyNames<T> = {
|
||||
[K in keyof T]: T[K] extends (...args: Array<any>) => any ? never : K;
|
||||
}[keyof T] & string;
|
||||
declare type FunctionPropertyNames<T> = {
|
||||
[K in keyof T]: T[K] extends (...args: Array<any>) => any ? K : never;
|
||||
}[keyof T] & string;
|
||||
interface Mock<T, Y extends Array<unknown> = Array<unknown>> extends Function, MockInstance<T, Y> {
|
||||
new (...args: Y): T;
|
||||
(...args: Y): T;
|
||||
}
|
||||
interface SpyInstance<T, Y extends Array<unknown>> extends MockInstance<T, Y> {
|
||||
}
|
||||
interface MockInstance<T, Y extends Array<unknown>> {
|
||||
_isMockFunction: true;
|
||||
_protoImpl: Function;
|
||||
getMockName(): string;
|
||||
getMockImplementation(): Function | undefined;
|
||||
mock: MockFunctionState<T, Y>;
|
||||
mockClear(): this;
|
||||
mockReset(): this;
|
||||
mockRestore(): void;
|
||||
mockImplementation(fn: (...args: Y) => T): this;
|
||||
mockImplementation(fn: () => Promise<T>): this;
|
||||
mockImplementationOnce(fn: (...args: Y) => T): this;
|
||||
mockImplementationOnce(fn: () => Promise<T>): this;
|
||||
mockName(name: string): this;
|
||||
mockReturnThis(): this;
|
||||
mockReturnValue(value: T): this;
|
||||
mockReturnValueOnce(value: T): this;
|
||||
mockResolvedValue(value: T): this;
|
||||
mockResolvedValueOnce(value: T): this;
|
||||
mockRejectedValue(value: T): this;
|
||||
mockRejectedValueOnce(value: T): this;
|
||||
}
|
||||
declare class ModuleMockerClass {
|
||||
private _environmentGlobal;
|
||||
private _mockState;
|
||||
private _mockConfigRegistry;
|
||||
private _spyState;
|
||||
private _invocationCallCounter;
|
||||
ModuleMocker: typeof ModuleMockerClass;
|
||||
/**
|
||||
* @see README.md
|
||||
* @param global Global object of the test environment, used to create
|
||||
* mocks
|
||||
*/
|
||||
constructor(global: Global);
|
||||
private _getSlots;
|
||||
private _ensureMockConfig;
|
||||
private _ensureMockState;
|
||||
private _defaultMockConfig;
|
||||
private _defaultMockState;
|
||||
private _makeComponent;
|
||||
private _createMockFunction;
|
||||
private _generateMock;
|
||||
/**
|
||||
* @see README.md
|
||||
* @param _metadata Metadata for the mock in the schema returned by the
|
||||
* getMetadata method of this module.
|
||||
*/
|
||||
generateFromMetadata<T, Y extends Array<unknown>>(_metadata: JestMock.MockFunctionMetadata<T, Y>): Mock<T, Y>;
|
||||
/**
|
||||
* @see README.md
|
||||
* @param component The component for which to retrieve metadata.
|
||||
*/
|
||||
getMetadata<T, Y extends Array<unknown>>(component: T, _refs?: Map<T, number>): JestMock.MockFunctionMetadata<T, Y> | null;
|
||||
isMockFunction<T>(fn: any): fn is Mock<T>;
|
||||
fn<T, Y extends Array<unknown>>(implementation?: (...args: Y) => T): Mock<T, Y>;
|
||||
spyOn<T extends {}, M extends NonFunctionPropertyNames<T>>(object: T, methodName: M, accessType: 'get'): SpyInstance<T[M], []>;
|
||||
spyOn<T extends {}, M extends NonFunctionPropertyNames<T>>(object: T, methodName: M, accessType: 'set'): SpyInstance<void, [T[M]]>;
|
||||
spyOn<T extends {}, M extends FunctionPropertyNames<T>>(object: T, methodName: M): T[M] extends (...args: Array<any>) => any ? SpyInstance<ReturnType<T[M]>, Parameters<T[M]>> : never;
|
||||
private _spyOnProperty;
|
||||
clearAllMocks(): void;
|
||||
resetAllMocks(): void;
|
||||
restoreAllMocks(): void;
|
||||
private _typeOf;
|
||||
}
|
||||
declare const JestMock: ModuleMockerClass;
|
||||
export = JestMock;
|
||||
//# sourceMappingURL=index.d.ts.map
|
||||
1
node_modules/jest-mock/build/index.d.ts.map
generated
vendored
Normal file
1
node_modules/jest-mock/build/index.d.ts.map
generated
vendored
Normal file
|
|
@ -0,0 +1 @@
|
|||
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}
|
||||
967
node_modules/jest-mock/build/index.js
generated
vendored
Normal file
967
node_modules/jest-mock/build/index.js
generated
vendored
Normal file
|
|
@ -0,0 +1,967 @@
|
|||
'use strict';
|
||||
|
||||
function _defineProperty(obj, key, value) {
|
||||
if (key in obj) {
|
||||
Object.defineProperty(obj, key, {
|
||||
value: value,
|
||||
enumerable: true,
|
||||
configurable: true,
|
||||
writable: true
|
||||
});
|
||||
} else {
|
||||
obj[key] = value;
|
||||
}
|
||||
return obj;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
|
||||
*
|
||||
* This source code is licensed under the MIT license found in the
|
||||
* LICENSE file in the root directory of this source tree.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Possible types of a MockFunctionResult.
|
||||
* 'return': The call completed by returning normally.
|
||||
* 'throw': The call completed by throwing a value.
|
||||
* 'incomplete': The call has not completed yet. This is possible if you read
|
||||
* the mock function result from within the mock function itself
|
||||
* (or a function called by the mock function).
|
||||
*/
|
||||
|
||||
/**
|
||||
* Represents the result of a single call to a mock function.
|
||||
*/
|
||||
// see https://github.com/Microsoft/TypeScript/issues/25215
|
||||
const MOCK_CONSTRUCTOR_NAME = 'mockConstructor';
|
||||
const FUNCTION_NAME_RESERVED_PATTERN = /[\s!-\/:-@\[-`{-~]/;
|
||||
const FUNCTION_NAME_RESERVED_REPLACE = new RegExp(
|
||||
FUNCTION_NAME_RESERVED_PATTERN.source,
|
||||
'g'
|
||||
);
|
||||
const RESERVED_KEYWORDS = new Set([
|
||||
'arguments',
|
||||
'await',
|
||||
'break',
|
||||
'case',
|
||||
'catch',
|
||||
'class',
|
||||
'const',
|
||||
'continue',
|
||||
'debugger',
|
||||
'default',
|
||||
'delete',
|
||||
'do',
|
||||
'else',
|
||||
'enum',
|
||||
'eval',
|
||||
'export',
|
||||
'extends',
|
||||
'false',
|
||||
'finally',
|
||||
'for',
|
||||
'function',
|
||||
'if',
|
||||
'implements',
|
||||
'import',
|
||||
'in',
|
||||
'instanceof',
|
||||
'interface',
|
||||
'let',
|
||||
'new',
|
||||
'null',
|
||||
'package',
|
||||
'private',
|
||||
'protected',
|
||||
'public',
|
||||
'return',
|
||||
'static',
|
||||
'super',
|
||||
'switch',
|
||||
'this',
|
||||
'throw',
|
||||
'true',
|
||||
'try',
|
||||
'typeof',
|
||||
'var',
|
||||
'void',
|
||||
'while',
|
||||
'with',
|
||||
'yield'
|
||||
]);
|
||||
|
||||
function matchArity(fn, length) {
|
||||
let mockConstructor;
|
||||
|
||||
switch (length) {
|
||||
case 1:
|
||||
mockConstructor = function mockConstructor(_a) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
break;
|
||||
|
||||
case 2:
|
||||
mockConstructor = function mockConstructor(_a, _b) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
break;
|
||||
|
||||
case 3:
|
||||
mockConstructor = function mockConstructor(_a, _b, _c) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
break;
|
||||
|
||||
case 4:
|
||||
mockConstructor = function mockConstructor(_a, _b, _c, _d) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
break;
|
||||
|
||||
case 5:
|
||||
mockConstructor = function mockConstructor(_a, _b, _c, _d, _e) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
break;
|
||||
|
||||
case 6:
|
||||
mockConstructor = function mockConstructor(_a, _b, _c, _d, _e, _f) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
break;
|
||||
|
||||
case 7:
|
||||
mockConstructor = function mockConstructor(_a, _b, _c, _d, _e, _f, _g) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
break;
|
||||
|
||||
case 8:
|
||||
mockConstructor = function mockConstructor(
|
||||
_a,
|
||||
_b,
|
||||
_c,
|
||||
_d,
|
||||
_e,
|
||||
_f,
|
||||
_g,
|
||||
_h
|
||||
) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
break;
|
||||
|
||||
case 9:
|
||||
mockConstructor = function mockConstructor(
|
||||
_a,
|
||||
_b,
|
||||
_c,
|
||||
_d,
|
||||
_e,
|
||||
_f,
|
||||
_g,
|
||||
_h,
|
||||
_i
|
||||
) {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
mockConstructor = function mockConstructor() {
|
||||
return fn.apply(this, arguments);
|
||||
};
|
||||
|
||||
break;
|
||||
}
|
||||
|
||||
return mockConstructor;
|
||||
}
|
||||
|
||||
function getObjectType(value) {
|
||||
return Object.prototype.toString.apply(value).slice(8, -1);
|
||||
}
|
||||
|
||||
function getType(ref) {
|
||||
const typeName = getObjectType(ref);
|
||||
|
||||
if (
|
||||
typeName === 'Function' ||
|
||||
typeName === 'AsyncFunction' ||
|
||||
typeName === 'GeneratorFunction'
|
||||
) {
|
||||
return 'function';
|
||||
} else if (Array.isArray(ref)) {
|
||||
return 'array';
|
||||
} else if (typeName === 'Object') {
|
||||
return 'object';
|
||||
} else if (
|
||||
typeName === 'Number' ||
|
||||
typeName === 'String' ||
|
||||
typeName === 'Boolean' ||
|
||||
typeName === 'Symbol'
|
||||
) {
|
||||
return 'constant';
|
||||
} else if (
|
||||
typeName === 'Map' ||
|
||||
typeName === 'WeakMap' ||
|
||||
typeName === 'Set'
|
||||
) {
|
||||
return 'collection';
|
||||
} else if (typeName === 'RegExp') {
|
||||
return 'regexp';
|
||||
} else if (ref === undefined) {
|
||||
return 'undefined';
|
||||
} else if (ref === null) {
|
||||
return 'null';
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
function isReadonlyProp(object, prop) {
|
||||
if (
|
||||
prop === 'arguments' ||
|
||||
prop === 'caller' ||
|
||||
prop === 'callee' ||
|
||||
prop === 'name' ||
|
||||
prop === 'length'
|
||||
) {
|
||||
const typeName = getObjectType(object);
|
||||
return (
|
||||
typeName === 'Function' ||
|
||||
typeName === 'AsyncFunction' ||
|
||||
typeName === 'GeneratorFunction'
|
||||
);
|
||||
}
|
||||
|
||||
if (
|
||||
prop === 'source' ||
|
||||
prop === 'global' ||
|
||||
prop === 'ignoreCase' ||
|
||||
prop === 'multiline'
|
||||
) {
|
||||
return getObjectType(object) === 'RegExp';
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
class ModuleMockerClass {
|
||||
/**
|
||||
* @see README.md
|
||||
* @param global Global object of the test environment, used to create
|
||||
* mocks
|
||||
*/
|
||||
constructor(global) {
|
||||
_defineProperty(this, '_environmentGlobal', void 0);
|
||||
|
||||
_defineProperty(this, '_mockState', void 0);
|
||||
|
||||
_defineProperty(this, '_mockConfigRegistry', void 0);
|
||||
|
||||
_defineProperty(this, '_spyState', void 0);
|
||||
|
||||
_defineProperty(this, '_invocationCallCounter', void 0);
|
||||
|
||||
_defineProperty(this, 'ModuleMocker', void 0);
|
||||
|
||||
this._environmentGlobal = global;
|
||||
this._mockState = new WeakMap();
|
||||
this._mockConfigRegistry = new WeakMap();
|
||||
this._spyState = new Set();
|
||||
this.ModuleMocker = ModuleMockerClass;
|
||||
this._invocationCallCounter = 1;
|
||||
}
|
||||
|
||||
_getSlots(object) {
|
||||
if (!object) {
|
||||
return [];
|
||||
}
|
||||
|
||||
const slots = new Set();
|
||||
const EnvObjectProto = this._environmentGlobal.Object.prototype;
|
||||
const EnvFunctionProto = this._environmentGlobal.Function.prototype;
|
||||
const EnvRegExpProto = this._environmentGlobal.RegExp.prototype; // Also check the builtins in the current context as they leak through
|
||||
// core node modules.
|
||||
|
||||
const ObjectProto = Object.prototype;
|
||||
const FunctionProto = Function.prototype;
|
||||
const RegExpProto = RegExp.prototype; // Properties of Object.prototype, Function.prototype and RegExp.prototype
|
||||
// are never reported as slots
|
||||
|
||||
while (
|
||||
object != null &&
|
||||
object !== EnvObjectProto &&
|
||||
object !== EnvFunctionProto &&
|
||||
object !== EnvRegExpProto &&
|
||||
object !== ObjectProto &&
|
||||
object !== FunctionProto &&
|
||||
object !== RegExpProto
|
||||
) {
|
||||
const ownNames = Object.getOwnPropertyNames(object);
|
||||
|
||||
for (let i = 0; i < ownNames.length; i++) {
|
||||
const prop = ownNames[i];
|
||||
|
||||
if (!isReadonlyProp(object, prop)) {
|
||||
const propDesc = Object.getOwnPropertyDescriptor(object, prop); // @ts-ignore Object.__esModule
|
||||
|
||||
if ((propDesc !== undefined && !propDesc.get) || object.__esModule) {
|
||||
slots.add(prop);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
object = Object.getPrototypeOf(object);
|
||||
}
|
||||
|
||||
return Array.from(slots);
|
||||
}
|
||||
|
||||
_ensureMockConfig(f) {
|
||||
let config = this._mockConfigRegistry.get(f);
|
||||
|
||||
if (!config) {
|
||||
config = this._defaultMockConfig();
|
||||
|
||||
this._mockConfigRegistry.set(f, config);
|
||||
}
|
||||
|
||||
return config;
|
||||
}
|
||||
|
||||
_ensureMockState(f) {
|
||||
let state = this._mockState.get(f);
|
||||
|
||||
if (!state) {
|
||||
state = this._defaultMockState();
|
||||
|
||||
this._mockState.set(f, state);
|
||||
}
|
||||
|
||||
return state;
|
||||
}
|
||||
|
||||
_defaultMockConfig() {
|
||||
return {
|
||||
defaultReturnValue: undefined,
|
||||
isReturnValueLastSet: false,
|
||||
mockImpl: undefined,
|
||||
mockName: 'jest.fn()',
|
||||
specificMockImpls: [],
|
||||
specificReturnValues: []
|
||||
};
|
||||
}
|
||||
|
||||
_defaultMockState() {
|
||||
return {
|
||||
calls: [],
|
||||
instances: [],
|
||||
invocationCallOrder: [],
|
||||
results: []
|
||||
};
|
||||
}
|
||||
|
||||
_makeComponent(metadata, restore) {
|
||||
if (metadata.type === 'object') {
|
||||
return new this._environmentGlobal.Object();
|
||||
} else if (metadata.type === 'array') {
|
||||
return new this._environmentGlobal.Array();
|
||||
} else if (metadata.type === 'regexp') {
|
||||
return new this._environmentGlobal.RegExp('');
|
||||
} else if (
|
||||
metadata.type === 'constant' ||
|
||||
metadata.type === 'collection' ||
|
||||
metadata.type === 'null' ||
|
||||
metadata.type === 'undefined'
|
||||
) {
|
||||
return metadata.value;
|
||||
} else if (metadata.type === 'function') {
|
||||
const prototype =
|
||||
(metadata.members &&
|
||||
metadata.members.prototype &&
|
||||
metadata.members.prototype.members) ||
|
||||
{};
|
||||
|
||||
const prototypeSlots = this._getSlots(prototype);
|
||||
|
||||
const mocker = this;
|
||||
const mockConstructor = matchArity(function(...args) {
|
||||
const mockState = mocker._ensureMockState(f);
|
||||
|
||||
const mockConfig = mocker._ensureMockConfig(f);
|
||||
|
||||
mockState.instances.push(this);
|
||||
mockState.calls.push(args); // Create and record an "incomplete" mock result immediately upon
|
||||
// calling rather than waiting for the mock to return. This avoids
|
||||
// issues caused by recursion where results can be recorded in the
|
||||
// wrong order.
|
||||
|
||||
const mockResult = {
|
||||
type: 'incomplete',
|
||||
value: undefined
|
||||
};
|
||||
mockState.results.push(mockResult);
|
||||
mockState.invocationCallOrder.push(mocker._invocationCallCounter++); // Will be set to the return value of the mock if an error is not thrown
|
||||
|
||||
let finalReturnValue; // Will be set to the error that is thrown by the mock (if it throws)
|
||||
|
||||
let thrownError; // Will be set to true if the mock throws an error. The presence of a
|
||||
// value in `thrownError` is not a 100% reliable indicator because a
|
||||
// function could throw a value of undefined.
|
||||
|
||||
let callDidThrowError = false;
|
||||
|
||||
try {
|
||||
// The bulk of the implementation is wrapped in an immediately
|
||||
// executed arrow function so the return value of the mock function
|
||||
// can be easily captured and recorded, despite the many separate
|
||||
// return points within the logic.
|
||||
finalReturnValue = (() => {
|
||||
if (this instanceof f) {
|
||||
// This is probably being called as a constructor
|
||||
prototypeSlots.forEach(slot => {
|
||||
// Copy prototype methods to the instance to make
|
||||
// it easier to interact with mock instance call and
|
||||
// return values
|
||||
if (prototype[slot].type === 'function') {
|
||||
// @ts-ignore no index signature
|
||||
const protoImpl = this[slot]; // @ts-ignore no index signature
|
||||
|
||||
this[slot] = mocker.generateFromMetadata(prototype[slot]); // @ts-ignore no index signature
|
||||
|
||||
this[slot]._protoImpl = protoImpl;
|
||||
}
|
||||
}); // Run the mock constructor implementation
|
||||
|
||||
const mockImpl = mockConfig.specificMockImpls.length
|
||||
? mockConfig.specificMockImpls.shift()
|
||||
: mockConfig.mockImpl;
|
||||
return mockImpl && mockImpl.apply(this, arguments);
|
||||
}
|
||||
|
||||
const returnValue = mockConfig.defaultReturnValue; // If return value is last set, either specific or default, i.e.
|
||||
// mockReturnValueOnce()/mockReturnValue() is called and no
|
||||
// mockImplementationOnce()/mockImplementation() is called after
|
||||
// that.
|
||||
// use the set return value.
|
||||
|
||||
if (mockConfig.specificReturnValues.length) {
|
||||
return mockConfig.specificReturnValues.shift();
|
||||
}
|
||||
|
||||
if (mockConfig.isReturnValueLastSet) {
|
||||
return mockConfig.defaultReturnValue;
|
||||
} // If mockImplementationOnce()/mockImplementation() is last set,
|
||||
// or specific return values are used up, use the mock
|
||||
// implementation.
|
||||
|
||||
let specificMockImpl;
|
||||
|
||||
if (returnValue === undefined) {
|
||||
specificMockImpl = mockConfig.specificMockImpls.shift();
|
||||
|
||||
if (specificMockImpl === undefined) {
|
||||
specificMockImpl = mockConfig.mockImpl;
|
||||
}
|
||||
|
||||
if (specificMockImpl) {
|
||||
return specificMockImpl.apply(this, arguments);
|
||||
}
|
||||
} // Otherwise use prototype implementation
|
||||
|
||||
if (returnValue === undefined && f._protoImpl) {
|
||||
return f._protoImpl.apply(this, arguments);
|
||||
}
|
||||
|
||||
return returnValue;
|
||||
})();
|
||||
} catch (error) {
|
||||
// Store the thrown error so we can record it, then re-throw it.
|
||||
thrownError = error;
|
||||
callDidThrowError = true;
|
||||
throw error;
|
||||
} finally {
|
||||
// Record the result of the function.
|
||||
// NOTE: Intentionally NOT pushing/indexing into the array of mock
|
||||
// results here to avoid corrupting results data if mockClear()
|
||||
// is called during the execution of the mock.
|
||||
mockResult.type = callDidThrowError ? 'throw' : 'return';
|
||||
mockResult.value = callDidThrowError ? thrownError : finalReturnValue;
|
||||
}
|
||||
|
||||
return finalReturnValue;
|
||||
}, metadata.length || 0);
|
||||
|
||||
const f = this._createMockFunction(metadata, mockConstructor);
|
||||
|
||||
f._isMockFunction = true;
|
||||
|
||||
f.getMockImplementation = () => this._ensureMockConfig(f).mockImpl;
|
||||
|
||||
if (typeof restore === 'function') {
|
||||
this._spyState.add(restore);
|
||||
}
|
||||
|
||||
this._mockState.set(f, this._defaultMockState());
|
||||
|
||||
this._mockConfigRegistry.set(f, this._defaultMockConfig());
|
||||
|
||||
Object.defineProperty(f, 'mock', {
|
||||
configurable: false,
|
||||
enumerable: true,
|
||||
get: () => this._ensureMockState(f),
|
||||
set: val => this._mockState.set(f, val)
|
||||
});
|
||||
|
||||
f.mockClear = () => {
|
||||
this._mockState.delete(f);
|
||||
|
||||
return f;
|
||||
};
|
||||
|
||||
f.mockReset = () => {
|
||||
f.mockClear();
|
||||
|
||||
this._mockConfigRegistry.delete(f);
|
||||
|
||||
return f;
|
||||
};
|
||||
|
||||
f.mockRestore = () => {
|
||||
f.mockReset();
|
||||
return restore ? restore() : undefined;
|
||||
};
|
||||
|
||||
f.mockReturnValueOnce = value => {
|
||||
// next function call will return this value or default return value
|
||||
const mockConfig = this._ensureMockConfig(f);
|
||||
|
||||
mockConfig.specificReturnValues.push(value);
|
||||
return f;
|
||||
};
|
||||
|
||||
f.mockResolvedValueOnce = value =>
|
||||
f.mockImplementationOnce(() => Promise.resolve(value));
|
||||
|
||||
f.mockRejectedValueOnce = value =>
|
||||
f.mockImplementationOnce(() => Promise.reject(value));
|
||||
|
||||
f.mockReturnValue = value => {
|
||||
// next function call will return specified return value or this one
|
||||
const mockConfig = this._ensureMockConfig(f);
|
||||
|
||||
mockConfig.isReturnValueLastSet = true;
|
||||
mockConfig.defaultReturnValue = value;
|
||||
return f;
|
||||
};
|
||||
|
||||
f.mockResolvedValue = value =>
|
||||
f.mockImplementation(() => Promise.resolve(value));
|
||||
|
||||
f.mockRejectedValue = value =>
|
||||
f.mockImplementation(() => Promise.reject(value));
|
||||
|
||||
f.mockImplementationOnce = fn => {
|
||||
// next function call will use this mock implementation return value
|
||||
// or default mock implementation return value
|
||||
const mockConfig = this._ensureMockConfig(f);
|
||||
|
||||
mockConfig.isReturnValueLastSet = false;
|
||||
mockConfig.specificMockImpls.push(fn);
|
||||
return f;
|
||||
};
|
||||
|
||||
f.mockImplementation = fn => {
|
||||
// next function call will use mock implementation return value
|
||||
const mockConfig = this._ensureMockConfig(f);
|
||||
|
||||
mockConfig.isReturnValueLastSet = false;
|
||||
mockConfig.defaultReturnValue = undefined;
|
||||
mockConfig.mockImpl = fn;
|
||||
return f;
|
||||
};
|
||||
|
||||
f.mockReturnThis = () =>
|
||||
f.mockImplementation(function() {
|
||||
return this;
|
||||
});
|
||||
|
||||
f.mockName = name => {
|
||||
if (name) {
|
||||
const mockConfig = this._ensureMockConfig(f);
|
||||
|
||||
mockConfig.mockName = name;
|
||||
}
|
||||
|
||||
return f;
|
||||
};
|
||||
|
||||
f.getMockName = () => {
|
||||
const mockConfig = this._ensureMockConfig(f);
|
||||
|
||||
return mockConfig.mockName || 'jest.fn()';
|
||||
};
|
||||
|
||||
if (metadata.mockImpl) {
|
||||
f.mockImplementation(metadata.mockImpl);
|
||||
}
|
||||
|
||||
return f;
|
||||
} else {
|
||||
const unknownType = metadata.type || 'undefined type';
|
||||
throw new Error('Unrecognized type ' + unknownType);
|
||||
}
|
||||
}
|
||||
|
||||
_createMockFunction(metadata, mockConstructor) {
|
||||
let name = metadata.name;
|
||||
|
||||
if (!name) {
|
||||
return mockConstructor;
|
||||
} // Preserve `name` property of mocked function.
|
||||
|
||||
const boundFunctionPrefix = 'bound ';
|
||||
let bindCall = ''; // if-do-while for perf reasons. The common case is for the if to fail.
|
||||
|
||||
if (name && name.startsWith(boundFunctionPrefix)) {
|
||||
do {
|
||||
name = name.substring(boundFunctionPrefix.length); // Call bind() just to alter the function name.
|
||||
|
||||
bindCall = '.bind(null)';
|
||||
} while (name && name.startsWith(boundFunctionPrefix));
|
||||
} // Special case functions named `mockConstructor` to guard for infinite
|
||||
// loops.
|
||||
|
||||
if (name === MOCK_CONSTRUCTOR_NAME) {
|
||||
return mockConstructor;
|
||||
}
|
||||
|
||||
if (
|
||||
// It's a syntax error to define functions with a reserved keyword
|
||||
// as name.
|
||||
RESERVED_KEYWORDS.has(name) || // It's also a syntax error to define functions with a name that starts with a number
|
||||
/^\d/.test(name)
|
||||
) {
|
||||
name = '$' + name;
|
||||
} // It's also a syntax error to define a function with a reserved character
|
||||
// as part of it's name.
|
||||
|
||||
if (FUNCTION_NAME_RESERVED_PATTERN.test(name)) {
|
||||
name = name.replace(FUNCTION_NAME_RESERVED_REPLACE, '$');
|
||||
}
|
||||
|
||||
const body =
|
||||
'return function ' +
|
||||
name +
|
||||
'() {' +
|
||||
'return ' +
|
||||
MOCK_CONSTRUCTOR_NAME +
|
||||
'.apply(this,arguments);' +
|
||||
'}' +
|
||||
bindCall;
|
||||
const createConstructor = new this._environmentGlobal.Function(
|
||||
MOCK_CONSTRUCTOR_NAME,
|
||||
body
|
||||
);
|
||||
return createConstructor(mockConstructor);
|
||||
}
|
||||
|
||||
_generateMock(metadata, callbacks, refs) {
|
||||
// metadata not compatible but it's the same type, maybe problem with
|
||||
// overloading of _makeComponent and not _generateMock?
|
||||
// @ts-ignore
|
||||
const mock = this._makeComponent(metadata);
|
||||
|
||||
if (metadata.refID != null) {
|
||||
refs[metadata.refID] = mock;
|
||||
}
|
||||
|
||||
this._getSlots(metadata.members).forEach(slot => {
|
||||
const slotMetadata = (metadata.members && metadata.members[slot]) || {};
|
||||
|
||||
if (slotMetadata.ref != null) {
|
||||
callbacks.push(
|
||||
(function(ref) {
|
||||
return () => (mock[slot] = refs[ref]);
|
||||
})(slotMetadata.ref)
|
||||
);
|
||||
} else {
|
||||
mock[slot] = this._generateMock(slotMetadata, callbacks, refs);
|
||||
}
|
||||
});
|
||||
|
||||
if (
|
||||
metadata.type !== 'undefined' &&
|
||||
metadata.type !== 'null' &&
|
||||
mock.prototype &&
|
||||
typeof mock.prototype === 'object'
|
||||
) {
|
||||
mock.prototype.constructor = mock;
|
||||
}
|
||||
|
||||
return mock;
|
||||
}
|
||||
/**
|
||||
* @see README.md
|
||||
* @param _metadata Metadata for the mock in the schema returned by the
|
||||
* getMetadata method of this module.
|
||||
*/
|
||||
|
||||
generateFromMetadata(_metadata) {
|
||||
const callbacks = [];
|
||||
const refs = {};
|
||||
|
||||
const mock = this._generateMock(_metadata, callbacks, refs);
|
||||
|
||||
callbacks.forEach(setter => setter());
|
||||
return mock;
|
||||
}
|
||||
/**
|
||||
* @see README.md
|
||||
* @param component The component for which to retrieve metadata.
|
||||
*/
|
||||
|
||||
getMetadata(component, _refs) {
|
||||
const refs = _refs || new Map();
|
||||
const ref = refs.get(component);
|
||||
|
||||
if (ref != null) {
|
||||
return {
|
||||
ref
|
||||
};
|
||||
}
|
||||
|
||||
const type = getType(component);
|
||||
|
||||
if (!type) {
|
||||
return null;
|
||||
}
|
||||
|
||||
const metadata = {
|
||||
type
|
||||
};
|
||||
|
||||
if (
|
||||
type === 'constant' ||
|
||||
type === 'collection' ||
|
||||
type === 'undefined' ||
|
||||
type === 'null'
|
||||
) {
|
||||
metadata.value = component;
|
||||
return metadata;
|
||||
} else if (type === 'function') {
|
||||
// @ts-ignore this is a function so it has a name
|
||||
metadata.name = component.name; // @ts-ignore may be a mock
|
||||
|
||||
if (component._isMockFunction === true) {
|
||||
// @ts-ignore may be a mock
|
||||
metadata.mockImpl = component.getMockImplementation();
|
||||
}
|
||||
}
|
||||
|
||||
metadata.refID = refs.size;
|
||||
refs.set(component, metadata.refID);
|
||||
let members = null; // Leave arrays alone
|
||||
|
||||
if (type !== 'array') {
|
||||
this._getSlots(component).forEach(slot => {
|
||||
if (
|
||||
type === 'function' && // @ts-ignore may be a mock
|
||||
component._isMockFunction === true &&
|
||||
slot.match(/^mock/)
|
||||
) {
|
||||
return;
|
||||
} // @ts-ignore no index signature
|
||||
|
||||
const slotMetadata = this.getMetadata(component[slot], refs);
|
||||
|
||||
if (slotMetadata) {
|
||||
if (!members) {
|
||||
members = {};
|
||||
}
|
||||
|
||||
members[slot] = slotMetadata;
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (members) {
|
||||
metadata.members = members;
|
||||
}
|
||||
|
||||
return metadata;
|
||||
}
|
||||
|
||||
isMockFunction(fn) {
|
||||
return !!fn && fn._isMockFunction === true;
|
||||
}
|
||||
|
||||
fn(implementation) {
|
||||
const length = implementation ? implementation.length : 0;
|
||||
|
||||
const fn = this._makeComponent({
|
||||
length,
|
||||
type: 'function'
|
||||
});
|
||||
|
||||
if (implementation) {
|
||||
fn.mockImplementation(implementation);
|
||||
}
|
||||
|
||||
return fn;
|
||||
}
|
||||
|
||||
spyOn(object, methodName, accessType) {
|
||||
if (accessType) {
|
||||
return this._spyOnProperty(object, methodName, accessType);
|
||||
}
|
||||
|
||||
if (typeof object !== 'object' && typeof object !== 'function') {
|
||||
throw new Error(
|
||||
'Cannot spyOn on a primitive value; ' + this._typeOf(object) + ' given'
|
||||
);
|
||||
}
|
||||
|
||||
const original = object[methodName];
|
||||
|
||||
if (!this.isMockFunction(original)) {
|
||||
if (typeof original !== 'function') {
|
||||
throw new Error(
|
||||
'Cannot spy the ' +
|
||||
methodName +
|
||||
' property because it is not a function; ' +
|
||||
this._typeOf(original) +
|
||||
' given instead'
|
||||
);
|
||||
}
|
||||
|
||||
const isMethodOwner = object.hasOwnProperty(methodName); // @ts-ignore overriding original method with a Mock
|
||||
|
||||
object[methodName] = this._makeComponent(
|
||||
{
|
||||
type: 'function'
|
||||
},
|
||||
() => {
|
||||
if (isMethodOwner) {
|
||||
object[methodName] = original;
|
||||
} else {
|
||||
delete object[methodName];
|
||||
}
|
||||
}
|
||||
); // @ts-ignore original method is now a Mock
|
||||
|
||||
object[methodName].mockImplementation(function() {
|
||||
return original.apply(this, arguments);
|
||||
});
|
||||
}
|
||||
|
||||
return object[methodName];
|
||||
}
|
||||
|
||||
_spyOnProperty(obj, propertyName, accessType = 'get') {
|
||||
if (typeof obj !== 'object' && typeof obj !== 'function') {
|
||||
throw new Error(
|
||||
'Cannot spyOn on a primitive value; ' + this._typeOf(obj) + ' given'
|
||||
);
|
||||
}
|
||||
|
||||
if (!obj) {
|
||||
throw new Error(
|
||||
'spyOn could not find an object to spy upon for ' + propertyName + ''
|
||||
);
|
||||
}
|
||||
|
||||
if (!propertyName) {
|
||||
throw new Error('No property name supplied');
|
||||
}
|
||||
|
||||
let descriptor = Object.getOwnPropertyDescriptor(obj, propertyName);
|
||||
let proto = Object.getPrototypeOf(obj);
|
||||
|
||||
while (!descriptor && proto !== null) {
|
||||
descriptor = Object.getOwnPropertyDescriptor(proto, propertyName);
|
||||
proto = Object.getPrototypeOf(proto);
|
||||
}
|
||||
|
||||
if (!descriptor) {
|
||||
throw new Error(propertyName + ' property does not exist');
|
||||
}
|
||||
|
||||
if (!descriptor.configurable) {
|
||||
throw new Error(propertyName + ' is not declared configurable');
|
||||
}
|
||||
|
||||
if (!descriptor[accessType]) {
|
||||
throw new Error(
|
||||
'Property ' + propertyName + ' does not have access type ' + accessType
|
||||
);
|
||||
}
|
||||
|
||||
const original = descriptor[accessType];
|
||||
|
||||
if (!this.isMockFunction(original)) {
|
||||
if (typeof original !== 'function') {
|
||||
throw new Error(
|
||||
'Cannot spy the ' +
|
||||
propertyName +
|
||||
' property because it is not a function; ' +
|
||||
this._typeOf(original) +
|
||||
' given instead'
|
||||
);
|
||||
} // @ts-ignore: mock is assignable
|
||||
|
||||
descriptor[accessType] = this._makeComponent(
|
||||
{
|
||||
type: 'function'
|
||||
},
|
||||
() => {
|
||||
// @ts-ignore: mock is assignable
|
||||
descriptor[accessType] = original;
|
||||
Object.defineProperty(obj, propertyName, descriptor);
|
||||
}
|
||||
);
|
||||
descriptor[accessType].mockImplementation(function() {
|
||||
// @ts-ignore
|
||||
return original.apply(this, arguments);
|
||||
});
|
||||
}
|
||||
|
||||
Object.defineProperty(obj, propertyName, descriptor);
|
||||
return descriptor[accessType];
|
||||
}
|
||||
|
||||
clearAllMocks() {
|
||||
this._mockState = new WeakMap();
|
||||
}
|
||||
|
||||
resetAllMocks() {
|
||||
this._mockConfigRegistry = new WeakMap();
|
||||
this._mockState = new WeakMap();
|
||||
}
|
||||
|
||||
restoreAllMocks() {
|
||||
this._spyState.forEach(restore => restore());
|
||||
|
||||
this._spyState = new Set();
|
||||
}
|
||||
|
||||
_typeOf(value) {
|
||||
return value == null ? '' + value : typeof value;
|
||||
}
|
||||
}
|
||||
/* eslint-disable-next-line no-redeclare */
|
||||
|
||||
const JestMock = new ModuleMockerClass(global);
|
||||
module.exports = JestMock;
|
||||
Loading…
Add table
Add a link
Reference in a new issue