error log - jest.spyOn()에서 재사용함수에 대한 모의 불가

// ...
const checkDuplicateEmail = async ( email: string ) => {
	...
}

const checkDuplicateNickname = async ( nickname: string ) => {
	...
}

const updateUserInfo = async (userId: number, userInfo: UserDto) => {  
	const originUserInfo = await UserRepository.findOne({  
	where: { id: userId },  
	});  
	  
	if (  
	userInfo.nickname === originUserInfo.nickname &&  
	userInfo.email === originUserInfo.email &&  
	!userInfo.password  
	) {  
	const error = new Error('NO_CHANGE');  
	error.status = 400;  
	throw error;  
	}  
	  
	if (  
	userInfo.nickname &&  
	userInfo.nickname !== originUserInfo.nickname &&  
	!userInfo.password  
	) {  
	// 아래 라인이 동일 파일 내 재사용되는 함수 1.
	await checkDuplicateNickname(userInfo.nickname);  
	}  
	  
	if (userInfo.email && userInfo.email !== originUserInfo.email) {  
	// 아래 라인이 동일 파일 내 재사용되는 함수 2.
	await checkDuplicateEmail(userInfo.email);  
	}  
	  
	if (userInfo.password) {  
	const salt = await bcrypt.genSalt();  
	userInfo.password = await bcrypt.hash(userInfo.password, salt);  
	}  
	  
	await UserRepository.update(userId, userInfo);  
	return await UserRepository.findOne({  
	where: { id: userId },  
	});  
};

const checkDuplicateNickname = async (nickname: string): Promise<object> => {  
	if (!nickname) {  
		const error = new Error(`NICKNAME_IS_UNDEFINED`);  
		error.status = 400;  
		throw error;  
	}  
	// const checkData = await userRepository.findOneBy({ nickname: nickname });  
	const checkData = await User.findByNickname(nickname);  
	  
	if (!checkData) {  
		return { message: 'AVAILABLE_NICKNAME' };  
	}  
	  
	if (checkData.nickname === nickname) {  
		const err = new Error(  
		`${checkData.nickname}_IS_NICKNAME_THAT_ALREADY_EXSITS`  
		);  
		err.status = 409;  
		throw err;  
	}  
};

const checkDuplicateEmail = async (email: string): Promise<object> => {  
	if (!email) {  
		const error = new Error(`EMAIL_IS_UNDEFINED`);  
		error.status = 400;  
		throw error;  
	}  
	const checkData = await User.findByEmail(email);  
	  
	if (!checkData) {  
		return { message: 'AVAILABLE_EMAIL' };  
	}  
	  
	if (checkData.email === email) {  
		const err = new Error(`${checkData.email}_IS_EMAIL_THAT_ALREADY_EXSITS`);  
		err.status = 409;  
		throw err;  
	}  
};

describe('updateUserInfo', () => {  
	const userId = 1;  
	  
	const originUserInfo = {  
		id: userId,  
		nickname: 'oldNickname',  
		email: '[email protected]',  
		password: 'oldPassword',  
	};  
  
	beforeEach(() => {  
		jest.resetAllMocks();  
	  
		UserRepository.findOne = jest.fn().mockResolvedValue(originUserInfo);  
		UserRepository.update = jest.fn().mockResolvedValue(true);  
		
		// 지저분한 모의 코드
		// 모의하는 함수가 아닌 그 함수의 메소드를 모의함으로 코드 해석시 가독성이 떨어진다.
		// 만약 재사용되는 함수 내부의 메소드가 많으면 많을수록 불필요한 모의가 더 늘어나게 된다.
		User.findByNickname = jest.fn().mockResolvedValue(null);  
		User.findByEmail = jest.fn().mockResolvedValue(null);  
		
		bcrypt.genSalt = jest.fn().mockResolvedValue('salt');  
		bcrypt.hash = jest.fn().mockResolvedValue('hashedPassword');  
	});  
  
	afterAll(() => {  
		jest.restoreAllMocks();  
	});

	test('사용자 정보 수정 - 닉네임 변경 성공시, 닉네임 중복 여부 확인', async () => {  
		const newUserInfo: UserDto = {  
			nickname: 'newNickname',  
			email: '[email protected]',  
			password: 'newPassword',  
		};  
		
		const checkDuplicateNicknameSpy = jest.spyOn(  
			usersService,  
			'checkDuplicateNickname'  
		);  
		  
		await usersService.updateUserInfo(userId, newUserInfo);  
		  
	// 아래 라인부터 문제의 코드 ---------- spyOn으로 추적이 안된다!! 
		expect(usersService.checkDuplicateNickname).toHaveBeenCalled();  
		  
		expect(checkDuplicateNicknameSpy).toHaveBeenCalledWith(  
			newUserInfo.nickname  
		);  
	})
});

export class UserService {
	checkDuplicateEmail = async ( email: string ) => {
		...
	}
	
	checkDuplicateNickname = async ( nickname: string ) => {
		...
	}
	
	updateUserInfo = async (userId: number, userInfo: UserDto) => {  
		...
		// 아래 라인이 동일 파일 내 재사용되는 함수 1.
		await this.checkDuplicateNickname(userInfo.nickname);  
		  
		// 아래 라인이 동일 파일 내 재사용되는 함수 2.
		await this.checkDuplicateEmail(userInfo.email);   
		  
		...
	};
};

import validateService from './validate.service.ts'

const updateUserInfo = async (userId: number, userInfo: UserDto) => {  
	// 이전 코드...
	
	// 아래 라인이 동일 파일 내 재사용되는 함수 1. => import한 메소드로 변경
	await validateService.checkDuplicateNickname(userInfo.nickname);  
	}  
	  
	if (userInfo.email && userInfo.email !== originUserInfo.email) {  
	// 아래 라인이 동일 파일 내 재사용되는 함수 2. => import한 메소드로 변경
	await validateService.checkDuplicateEmail(userInfo.email);  
	}  
	  
	// ... 이후 코드...
	});  
};

describe('updateUserInfo', () => {  
// 이전 코드...
  
beforeEach(() => {  
jest.resetAllMocks();  
  
UserRepository.findOne = jest.fn().mockResolvedValue(originUserInfo);  
UserRepository.update = jest.fn().mockResolvedValue(true);


// 간단하게 모의 끝!! 해당 함수의 메소드가 아닌 함수 그 자체를 모의함으로 유지보수시 가독성 또한 높아진다.  
validateService.checkDuplicateNickname = jest.fn();  
validateService.checkDuplicateEmail = jest.fn();  

// 이후 코드 ..
});  
  
afterAll(() => {  
jest.restoreAllMocks();  
});  
    
it('사용자 정보 수정 - 닉네임 변경 성공시, 닉네임 중복 여부 확인', async () => {  
const newUserInfo: UserDto = {  
nickname: 'newNickname',  
email: originUserInfo.email,  
};  
  
await usersService.updateUserInfo(userId, newUserInfo);  

// 테스트 성공!! 
expect(usersService.checkDuplicateNickname).toHaveBeenCalled();
expect(usersService.checkDuplicateNickname).toHaveBeenCalledWith(newUserInfo.nickname);