247 lines
8.1 KiB
TypeScript
247 lines
8.1 KiB
TypeScript
/**
|
|
* Copyright 2025 LY Corporation
|
|
*
|
|
* LY Corporation licenses this file to you under the Apache License,
|
|
* version 2.0 (the "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at:
|
|
*
|
|
* https://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
import type { Server } from 'net';
|
|
import { faker } from '@faker-js/faker';
|
|
import type { INestApplication } from '@nestjs/common';
|
|
import { ValidationPipe } from '@nestjs/common';
|
|
import type { TestingModule } from '@nestjs/testing';
|
|
import { Test } from '@nestjs/testing';
|
|
import { getDataSourceToken } from '@nestjs/typeorm';
|
|
import { DateTime } from 'luxon';
|
|
import request from 'supertest';
|
|
import type { DataSource, Repository } from 'typeorm';
|
|
|
|
import { AppModule } from '@/app.module';
|
|
import { AuthService } from '@/domains/admin/auth/auth.service';
|
|
import { RoleEntity } from '@/domains/admin/project/role/role.entity';
|
|
import { TenantEntity } from '@/domains/admin/tenant/tenant.entity';
|
|
import { TenantService } from '@/domains/admin/tenant/tenant.service';
|
|
import type { UserDto } from '@/domains/admin/user/dtos';
|
|
import type { GetAllUserResponseDto } from '@/domains/admin/user/dtos/responses/get-all-user-response.dto';
|
|
import { UserStateEnum } from '@/domains/admin/user/entities/enums';
|
|
import { UserEntity } from '@/domains/admin/user/entities/user.entity';
|
|
import {
|
|
clearEntities,
|
|
createTenant,
|
|
getRandomEnumValue,
|
|
signInTestUser,
|
|
} from '@/test-utils/util-functions';
|
|
import { HttpStatusCode } from '@/types/http-status';
|
|
|
|
describe('UserController (integration)', () => {
|
|
let app: INestApplication;
|
|
|
|
let dataSource: DataSource;
|
|
let userRepo: Repository<UserEntity>;
|
|
let roleRepo: Repository<RoleEntity>;
|
|
let tenantRepo: Repository<TenantEntity>;
|
|
|
|
let tenantService: TenantService;
|
|
|
|
let authService: AuthService;
|
|
beforeAll(async () => {
|
|
const module: TestingModule = await Test.createTestingModule({
|
|
imports: [AppModule],
|
|
}).compile();
|
|
|
|
app = module.createNestApplication();
|
|
app.useGlobalPipes(
|
|
new ValidationPipe({ transform: true, whitelist: true }),
|
|
);
|
|
await app.init();
|
|
|
|
dataSource = module.get(getDataSourceToken());
|
|
userRepo = dataSource.getRepository(UserEntity);
|
|
roleRepo = dataSource.getRepository(RoleEntity);
|
|
tenantRepo = dataSource.getRepository(TenantEntity);
|
|
authService = module.get(AuthService);
|
|
tenantService = module.get(TenantService);
|
|
|
|
await clearEntities([tenantRepo, userRepo, roleRepo]);
|
|
|
|
await createTenant(tenantService);
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await dataSource.destroy();
|
|
await app.close();
|
|
});
|
|
|
|
let total: number;
|
|
let userEntities: UserEntity[];
|
|
let accessToken: string;
|
|
let ownerUser: UserEntity;
|
|
|
|
beforeEach(async () => {
|
|
await clearEntities([userRepo, roleRepo]);
|
|
|
|
const length = faker.number.int({ min: 3, max: 8 });
|
|
|
|
userEntities = (
|
|
await userRepo.save(
|
|
Array.from({ length: length }).map(() => ({
|
|
email: faker.internet.email(),
|
|
state: getRandomEnumValue(UserStateEnum),
|
|
hashPassword: faker.internet.password(),
|
|
})),
|
|
)
|
|
).sort((a, b) =>
|
|
DateTime.fromJSDate(b.createdAt)
|
|
.diff(DateTime.fromJSDate(a.createdAt))
|
|
.as('milliseconds'),
|
|
);
|
|
|
|
const { jwt, user } = await signInTestUser(dataSource, authService);
|
|
accessToken = jwt.accessToken;
|
|
ownerUser = user;
|
|
|
|
total = length + 1;
|
|
});
|
|
|
|
describe('/admin/users (GET)', () => {
|
|
it('should return all users', async () => {
|
|
const expectUsers = userEntities
|
|
.concat(ownerUser)
|
|
.sort((a, b) =>
|
|
DateTime.fromJSDate(a.createdAt)
|
|
.diff(DateTime.fromJSDate(b.createdAt))
|
|
.as('milliseconds'),
|
|
)
|
|
.map(({ id, email }) => ({
|
|
id,
|
|
email,
|
|
}))
|
|
.slice(0, 10);
|
|
|
|
return request(app.getHttpServer() as Server)
|
|
.get('/admin/users')
|
|
.set('Authorization', `Bearer ${accessToken}`)
|
|
.expect(HttpStatusCode.OK)
|
|
.expect(({ body }) => {
|
|
expect(body).toHaveProperty('items');
|
|
expect(body).toHaveProperty('meta');
|
|
|
|
const { items, meta } = body as GetAllUserResponseDto;
|
|
[
|
|
'name',
|
|
'department',
|
|
'type',
|
|
'members',
|
|
'createdAt',
|
|
'signUpMethod',
|
|
].forEach((field) => items.forEach((item) => delete item[field]));
|
|
expect(items).toEqual(expectUsers);
|
|
expect(meta.totalItems).toEqual(total);
|
|
});
|
|
});
|
|
|
|
it('should return unauthorized status code', async () => {
|
|
return request(app.getHttpServer() as Server)
|
|
.get('/admin/users')
|
|
.expect(HttpStatusCode.UNAUTHORIZED);
|
|
});
|
|
});
|
|
|
|
describe('/admin/users (DELETE)', () => {
|
|
it('should return empty result', async () => {
|
|
const ids = faker.helpers.arrayElements(userEntities).map((v) => v.id);
|
|
|
|
await request(app.getHttpServer() as Server)
|
|
.delete(`/admin/users`)
|
|
.set('Authorization', `Bearer ${accessToken}`)
|
|
.send({ ids })
|
|
.expect(HttpStatusCode.OK)
|
|
.then(async () => {
|
|
for (const id of ids) {
|
|
const result = await userRepo.findOneBy({ id });
|
|
expect(result).toBeNull();
|
|
}
|
|
});
|
|
});
|
|
|
|
it('should return unauthorized status code', async () => {
|
|
await request(app.getHttpServer() as Server)
|
|
.delete(`/admin/users`)
|
|
.expect(HttpStatusCode.UNAUTHORIZED);
|
|
});
|
|
});
|
|
|
|
describe('/admin/users/:id (GET)', () => {
|
|
it('check signed-in user', async () => {
|
|
await request(app.getHttpServer() as Server)
|
|
.get(`/admin/users/${ownerUser.id}`)
|
|
.set('Authorization', `Bearer ${accessToken}`)
|
|
.expect(200)
|
|
.expect(({ body }) => {
|
|
expect((body as UserDto).id).toEqual(ownerUser.id);
|
|
expect((body as UserDto).email).toEqual(ownerUser.email);
|
|
});
|
|
});
|
|
it('should return unauthorized status code', async () => {
|
|
await request(app.getHttpServer() as Server)
|
|
.get(`/admin/users/${ownerUser.id}`)
|
|
.expect(HttpStatusCode.UNAUTHORIZED);
|
|
});
|
|
});
|
|
|
|
describe('/admin/users/:id (DELETE)', () => {
|
|
it('should return empty result', async () => {
|
|
return request(app.getHttpServer() as Server)
|
|
.delete(`/admin/users/${ownerUser.id}`)
|
|
.set('Authorization', `Bearer ${accessToken}`)
|
|
.expect(HttpStatusCode.OK)
|
|
.then(async () => {
|
|
const result = await userRepo.findOneBy({ id: ownerUser.id });
|
|
expect(result).toBeNull();
|
|
});
|
|
});
|
|
it('should return unauthorized status code', async () => {
|
|
return request(app.getHttpServer() as Server)
|
|
.delete(`/admin/users/${faker.number.int()}`)
|
|
.set('Authorization', `Bearer ${accessToken}`)
|
|
.expect(HttpStatusCode.UNAUTHORIZED);
|
|
});
|
|
it('should return unauthorized status code', async () => {
|
|
return request(app.getHttpServer() as Server)
|
|
.delete(`/admin/users/${ownerUser.id}`)
|
|
.expect(HttpStatusCode.UNAUTHORIZED);
|
|
});
|
|
});
|
|
|
|
describe('/admin/users/:id/roles (GET)', () => {
|
|
it('should return OK', async () => {
|
|
await request(app.getHttpServer() as Server)
|
|
.get(`/admin/users/${ownerUser.id}/roles`)
|
|
.set('Authorization', `Bearer ${accessToken}`)
|
|
.expect(HttpStatusCode.OK);
|
|
});
|
|
});
|
|
|
|
describe('/admin/users/:id/roles (PUT)', () => {
|
|
it('should return unauthorized status code', async () => {
|
|
const role = await roleRepo.save({
|
|
name: faker.string.sample(),
|
|
permissions: [],
|
|
});
|
|
|
|
await request(app.getHttpServer() as Server)
|
|
.put(`/admin/users/${ownerUser.id}`)
|
|
.send({ roleId: role.id })
|
|
.expect(HttpStatusCode.UNAUTHORIZED);
|
|
});
|
|
});
|
|
});
|