Typescript ts笑话：导入MockedObject类型

如何将类型

MockedObject

导入测试文件？我的代码示例如下所示

从'ts jest/utils'导入{mocked，MockedObject}；
从“../src/common/someFunction”导入someFunction；
从“../src/model/SomeClass”导入SomeClass；
从“../src/interface/SomeInterface”导入SomeInterface；
mock（'../src/model/SomeClass'）；
描述（'运行测试'，（）=>{
让我们来验证：任何；
之前（异步（）=>{
mockedValidators=（wait someFunction（））.map（（v:SomeInterface）=>
嘲弄（五）
):
}
})

我试图从ts jest/utils导入

MockedObject

，但VSCode找不到它。我想用

MockedObject

替换

any

错误：

模块“../../../node_modules/ts jest/utils”没有导出的成员“MockedObject”

从中，我们可以看到

ts jest/utils

不导出

MockedObject

类型。您可以从

ts jest/dist/util/testing.d.ts

文件中复制类型，将它们添加到您的项目中

例如

index.test.ts

：

import { mocked } from 'ts-jest/utils';

interface SomeInterface {
  validate(): boolean;
}
declare type MockableFunction = (...args: any[]) => any;
declare type MethodKeysOf<T> = {
  [K in keyof T]: T[K] extends MockableFunction ? K : never;
}[keyof T];
declare type PropertyKeysOf<T> = {
  [K in keyof T]: T[K] extends MockableFunction ? never : K;
}[keyof T];
declare type ArgumentsOf<T> = T extends (...args: infer A) => any ? A : never;
declare type ConstructorArgumentsOf<T> = T extends new (...args: infer A) => any ? A : never;
interface MockWithArgs<T extends MockableFunction> extends jest.MockInstance<ReturnType<T>, ArgumentsOf<T>> {
  new (...args: ConstructorArgumentsOf<T>): T;
  (...args: ArgumentsOf<T>): ReturnType<T>;
}
declare type MaybeMockedConstructor<T> = T extends new (...args: any[]) => infer R ? jest.MockInstance<R, ConstructorArgumentsOf<T>> : {};
declare type MockedFunction<T extends MockableFunction> = MockWithArgs<T> &
  {
    [K in keyof T]: T[K];
  };
declare type MockedObject<T> = MaybeMockedConstructor<T> &
  {
    [K in MethodKeysOf<T>]: T[K] extends MockableFunction ? MockedFunction<T[K]> : T[K];
  } &
  {
    [K in PropertyKeysOf<T>]: T[K];
  };

const UserValidator: SomeInterface = {
  validate: () => true,
};

async function someFunction() {
  return [UserValidator];
}

describe('run test', () => {
  let mockedValidators: Array<MockedObject<SomeInterface>>;
  beforeAll(async () => {
    mockedValidators = (await someFunction()).map((v: SomeInterface) => mocked(v));
  });
});

从'ts jest/utils'导入{mocked}；
接口接口{
validate（）：布尔值；
}
声明类型MockableFunction=（…args:any[]）=>any；
声明类型MethodKeysOf={
[K in keyof T]：T[K]扩展了MockableFunction？K：从不；
}[keyof T]；
声明类型PropertyKeysOf={
[K in keyof T]：T[K]扩展了MockableFunction？never:K；
}[keyof T]；
declare type ArgumentsOf=T extends（…args:infera）=>any？A:never；
declare type ConstructorArgumentsOf=T扩展了new（…args:infera）=>any？A:never；
接口MockWithArgs扩展了jest.MockInstance{
新（…参数：ConstructorArgumentsOf）：T；
（…args:ArgumentsOf）：返回类型；
}
declare type MaybeMockedConstructor=T扩展了new（…args:any[]）=>inferr？jest.MockInstance:{}；
声明类型MockedFunction=MockWithArgs&
{
[K in keyof T]：T[K]；
};
声明类型MockedObject=MaybeMockedConstructor&
{
[K in MethodKeysOf]：T[K]扩展了MockableFunction？MockedFunction:T[K]；
} &
{
[K in PropertyKeysOf]：T[K]；
};
常量UserValidator:SomeInterface={
验证：（）=>true，
};
异步函数someFunction（）{
返回[UserValidator]；
}
描述（'运行测试'，（）=>{
让mockedValidators：数组；
之前（异步（）=>{
mockedValidators=（wait someFunction（））.map（（v:SomeInterface）=>mocked（v））；
});
});