update course us test

apps/server/src/modules/learnroom/uc/course.uc.spec.ts

@@ -1,28 +1,42 @@
 import { createMock, DeepMocked } from '@golevelup/ts-jest';
 import { AuthorizationService } from '@modules/authorization';
 import { ClassService } from '@modules/class';
+import { classFactory } from '@modules/class/domain/testing';
 import { GroupService } from '@modules/group';
+import { GroupRepo } from '@modules/group/repo/';
 import { RoleDto, RoleService } from '@modules/role';
 import { SchoolService } from '@modules/school';
 import { SCHOOL_REPO, SchoolRepo } from '@modules/school/domain/interface';
+import { schoolFactory } from '@modules/school/testing';
 import { UserService } from '@modules/user';
 import { Test, TestingModule } from '@nestjs/testing';
 import { Permission, RoleName, SortOrder } from '@shared/domain/interface';
 import { CourseRepo } from '@shared/repo';
-import { courseFactory, setupEntities, UserAndAccountTestFactory } from '@shared/testing';
-import { Course as CourseDO, COURSE_REPO, CourseRepo as CourseDORepo } from '../domain';
+import {
+	courseFactory,
+	groupFactory,
+	setupEntities,
+	UserAndAccountTestFactory,
+	userDoFactory,
+	userFactory,
+} from '@shared/testing';
+
+import { ClassesRepo } from '@modules/class/repo';
+import { UserDO } from '@shared/domain/domainobject';
+import { User } from '@shared/domain/entity';
+import { COURSE_REPO, CourseRepo as CourseDORepo, CourseSortQueryType, CourseStatusQueryType } from '../domain';
 import { CourseDoService, CourseService } from '../service';
-import { CourseUc } from './course.uc';
-import { CourseEntityMapper } from '../repo/mikro-orm/mapper/course.entity.mapper';
-import { schoolFactory } from '../../school/testing';
 import { courseFactory as courseDoFactory } from '../testing';
+import { CourseUc } from './course.uc';
 
 describe('CourseUc', () => {
 	let module: TestingModule;
 	let uc: CourseUc;
 	let courseRepo: DeepMocked<CourseRepo>;
 	let courseDORepo: DeepMocked<CourseDORepo>;
 	let schoolRepo: DeepMocked<SchoolRepo>;
+	let groupRepo: DeepMocked<GroupRepo>;
+	let classesRepo: DeepMocked<ClassesRepo>;
 
 	let courseService: DeepMocked<CourseService>;
 	let authorizationService: DeepMocked<AuthorizationService>;
@@ -74,6 +88,10 @@ describe('CourseUc', () => {
 					provide: GroupService,
 					useValue: createMock<GroupService>(),
 				},
+				{
+					provide: GroupRepo,
+					useValue: createMock<GroupRepo>(),
+				},
 				{
 					provide: UserService,
 					useValue: createMock<UserService>(),
@@ -82,6 +100,10 @@ describe('CourseUc', () => {
 					provide: ClassService,
 					useValue: createMock<ClassService>(),
 				},
+				{
+					provide: ClassesRepo,
+					useValue: createMock<ClassesRepo>(),
+				},
 			],
 		}).compile();
 
@@ -97,6 +119,8 @@ describe('CourseUc', () => {
 		classService = module.get(ClassService);
 		courseDORepo = module.get(COURSE_REPO);
 		schoolRepo = module.get(SCHOOL_REPO);
+		groupRepo = module.get(GroupRepo);
+		classesRepo = module.get(ClassesRepo);
 	});
 
 	afterAll(async () => {
@@ -171,4 +195,95 @@ describe('CourseUc', () => {
 			expect(courseService.findById).toHaveBeenCalledWith(course.id);
 		});
 	});
+
+	describe('findAllCourses', () => {
+		const setup = () => {
+			const user: User = userFactory.withRoleByName(RoleName.TEACHER).buildWithId();
+			const teacher: UserDO = userDoFactory.build({ id: user.id, firstName: 'firstName', lastName: 'lastName' });
+			const { adminUser } = UserAndAccountTestFactory.buildAdmin({}, [
+				Permission.COURSE_ADMINISTRATION,
+				Permission.ADMIN_VIEW,
+			]);
+			const group = groupFactory.build({ name: 'groupName' });
+			const clazz = classFactory.build({ name: 'A', gradeLevel: 1 });
+
+			const courses = courseDoFactory.buildList(5, {
+				syncedWithGroup: group.id,
+				teacherIds: [user.id],
+				groupIds: [group.id],
+				classIds: [clazz.id],
+			});
+			const pagination = { skip: 1, limit: 2 };
+			const courseStatusQueryType: CourseStatusQueryType = CourseStatusQueryType.CURRENT;
+			const sortByField: CourseSortQueryType = CourseSortQueryType.NAME;
+			const sortOrder: SortOrder = SortOrder.asc;
+
+			const school = schoolFactory.build();
+			schoolService.getSchoolById.mockResolvedValueOnce(school);
+			authorizationService.getUserWithPermissions.mockResolvedValue(adminUser);
+			authorizationService.checkPermission.mockReturnValueOnce(undefined);
+			courseDORepo.findCourses.mockResolvedValueOnce(courses);
+			courseDoService.findCourses.mockResolvedValueOnce(courses);
+			groupRepo.findGroupById.mockResolvedValue(group);
+			groupService.findById.mockResolvedValue(group);
+			userService.findById.mockResolvedValue(teacher);
+			groupService.findById.mockResolvedValue(group);
+			classService.findById.mockResolvedValue(clazz);
+			classesRepo.findClassById.mockResolvedValue(clazz);
+
+			return {
+				user,
+				courses,
+				pagination,
+				school,
+				adminUser,
+				group,
+				courseStatusQueryType,
+				sortByField,
+				sortOrder,
+				clazz,
+			};
+		};
+		it('should return courses of user', async () => {
+			const {
+				clazz,
+				group,
+				school,
+				adminUser,
+				sortByField,
+				courseStatusQueryType: statusTypeQuery,
+				pagination,
+				sortOrder,
+				user,
+			} = setup();
+
+			const result = await uc.findAllCourses(
+				adminUser.id,
+				school.id,
+				sortByField,
+				statusTypeQuery,
+				pagination,
+				sortOrder
+			);
+
+			expect(schoolService.getSchoolById).toHaveBeenCalledWith(school.id);
+			expect(authorizationService.getUserWithPermissions).toHaveBeenCalledWith(adminUser.id);
+			expect(authorizationService.checkPermission).toHaveBeenCalled();
+			const filter = { schoolId: school.id, courseStatusQueryType: statusTypeQuery };
+			const options = {
+				pagination,
+				order: {
+					[sortByField]: sortOrder,
+				},
+			};
+			expect(courseDoService.findCourses).toHaveBeenCalledWith(filter, options);
+			expect(userService.findById).toHaveBeenCalledWith(user.id);
+			expect(classService.findById).toHaveBeenCalledWith(clazz.id);
+			expect(groupService.findById).toHaveBeenCalledWith(group.id);
+			expect(result.total).toBe(5);
+			expect(result.data.length).toBe(5);
+			expect(result.data[0].classes).toStrictEqual(['1A', 'groupName']);
+			expect(result.data[0].teachers).toStrictEqual(['firstName lastName']);
+		});
+	});
 });