NetsJs 控制器单元测试返回类型错误:无法读取未定义的属性

Question

尝试在NetsJs控制器上编写单元测试，但返回类型错误：无法读取未定义的属性"getGroup">

groups.controller.spec.ts

describe("GroupsController", () => {
let groupsController: GroupsController;
let groupsService: GroupService;
beforeEach(async () => {
const module: TestingModule = await Test.createTestingModule({
controllers: [GroupsController],
providers: [
{
provide: getRepositoryToken(Groups),
useFactory: GroupModelMockFactory
},
{
provide: getRepositoryToken(Roles),
useFactory: roleModelMockFactory
},
RSTLogger,
RolesService,
GroupService,
CommonService,
DatabaseService,
GroupsController
]
}).compile();
groupsService = module.get<GroupService>(GroupService);
groupsController = module.get<GroupsController>(GroupsController);
});

it("should be defined", () => {
expect(groupsController).toBeDefined();
});
describe("Find Group", () => {
it("Get group", async () => {
try {
const expectedResult = {
groupName: "group123",
description: "Group Description",
roleId: 1
};
expect(
await groupsController.getGroup(1, 'no')
).toEqual({ data: expectedResult });
} catch (e) {
console.log(e);
}
});
});
});

单元测试模拟.ts

export const roleModelMockFactory = () => ({
findOne: id => ({
id: "1",
name: "Name",
description: "Description",
resource: []
}),
create: RoleDto => ({
name: "Role1",
description: "Role Description",
resource: []
}),
save: RoleDto => ({
name: "Role1",
description: "Role Description",
resource: []
}),
update: RoleDto => ({
exec: async () => ({
name: "Updated Role",
description: "Role Description",
resource: []
})
}),
findByIdAndRemove: id => ({
exec: async () => ({
name: "Deleted Role",
description: "Description",
resource: []
})
}),
});
export const GroupModelMockFactory = () => ({
findByRoleId: id => ({
groupName: "group123",
description: "Group Description",
roleId: 1
}),
findOne: dto => ({
groupName: "group123",
description: "Group Description",
roleId: 1
}),
create: groupDto => ({
groupName: "group123",
description: "Group Description",
roleId: 1
}),
save: groupDto => ({
groupName: "group123",
description: "Group Description",
roleId: 1
}),
findOneOrFail: id => ({
groupName: "group123",
description: "Group Description",
roleId: 1
}),
update: groupDto => ({
groupName: "group123",
description: "Group Description",
roleId: 1
}),
delete: id => ({
groupName: "group123",
description: "Group Description",
roleId: 1
}),
getGroup: id => ({
groupName: "group123",
description: "Group Description",
roleId: 1
})
});

groups.controller.ts

@ApiTags('groups')
@ApiBearerAuth()
@Controller('groups')
@Injectable({ scope: Scope.REQUEST })
export class GroupsController {
constructor(private readonly groupsService: GroupService,
private rstLogger: RSTLogger,
private commonService: CommonService,
@Inject(REQUEST) private readonly request: Request) {
this.rstLogger.setContext('GroupController');
}
@Get(':groupId')
@ApiQuery({ name: 'groupId' })
@ApiQuery({ name: 'relatinalData' , enum: ['yes', 'no']})
@UseGuards(JWTTokenAuthGuard, RolesGuard)
async gerGroup(@Query('groupId') groupId, @Query('relatinalData') relatinalFlag) {
const group = await this.groupsService.getGroup(groupId, relatinalFlag);
if (!group) throw new NotFoundException('Group does not exist!');
return { data: group };
}
}

group.service.ts

export class GroupService {
constructor(
@InjectRepository(Groups) private readonly groupModel: Repository<Groups>,
private rstLogger: RSTLogger,
private readonly databaseService: DatabaseService,
private readonly rolesService: RolesService) {
this.rstLogger.setContext('GroupServices');
}
async getGroup(ID, relatinalFlag = 'no'): Promise<Groups> {
if (relatinalFlag && relatinalData.yes === relatinalFlag) {
return await this.databaseService.findOneWithRelation(this.groupModel, { id: ID }, { relations: ['role'] });
} else {
return await this.databaseService.findOne(this.groupModel, { id: ID });
}
}
}

我在尝试从控制器获取组时出现以下错误

TypeError: Cannot read property 'getGroup' of undefined

谁能指导我这里需要正确的地方。

Answer 1

似乎GroupService的依赖项有自己的依赖项。如果它们对这个测试不重要，你可以这样模拟他们

{provide: RSTLogger, useValue: jest.fn() },

但正如我所看到的DatabaseService有自己的依赖性，应该适当地提供或嘲笑。