diff --git a/controllers/friendController.js b/controllers/friendController.js index a8411e34c4f0fde9e7970bc8841a0446833e2290..6dc37400fcfea24164af27d46070059b70cd3784 100644 --- a/controllers/friendController.js +++ b/controllers/friendController.js @@ -1,10 +1,6 @@ const FriendService = require('../services/friendService'); class friendController { - - - - class FriendController { /** * 친구 요청 보내기 * 클라이언트는 userId와 요청을 보낼 사용자의 email을 전송 @@ -37,12 +33,11 @@ class friendController { if (error.message === 'Friend request already exists') { return res.status(409).json({ message: error.message }); } + // 일반 오류 처리 return res.status(500).json({ message: '서버 오류가 발생했습니다.', error: error.message }); } } - } - /** * 받은 친구 요청 목록 조회 * GET /api/friend/requests/received @@ -195,7 +190,6 @@ class friendController { }); } } - } module.exports = new friendController(); \ No newline at end of file diff --git a/middleware/auth.js b/middlewares/auth.js similarity index 100% rename from middleware/auth.js rename to middlewares/auth.js diff --git a/package-lock.json b/package-lock.json index ea44223a36312ef0197fb5fc7195747f86c21694..cb3d8d14cd5330564553ceb4b9126c365d62f17a 100644 --- a/package-lock.json +++ b/package-lock.json @@ -18,6 +18,7 @@ "morgan": "^1.10.0", "multer": "^1.4.5-lts.1", "mysql2": "^3.11.4", + "node-cron": "^3.0.3", "passport": "^0.7.0", "passport-google-oauth20": "^2.0.0", "sequelize": "^6.37.5", @@ -11802,6 +11803,18 @@ "integrity": "sha512-CXdUiJembsNjuToQvxayPZF9Vqht7hewsvy2sOWafLvi2awflj9mOC6bHIg50orX8IJvWKY9wYQ/zB2kogPslQ==", "license": "ISC" }, + "node_modules/node-cron": { + "version": "3.0.3", + "resolved": "https://registry.npmjs.org/node-cron/-/node-cron-3.0.3.tgz", + "integrity": "sha512-dOal67//nohNgYWb+nWmg5dkFdIwDm8EpeGYMekPMrngV3637lqnX0lbUcCtgibHTz6SEz7DAIjKvKDFYCnO1A==", + "license": "ISC", + "dependencies": { + "uuid": "8.3.2" + }, + "engines": { + "node": ">=6.0.0" + } + }, "node_modules/node-gyp": { "version": "10.2.0", "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-10.2.0.tgz", diff --git a/package.json b/package.json index 48d1fb66671a2e13a190a34237941ad8de30ffbb..2151becb800731c9f2b5bb635082d01be0301abc 100644 --- a/package.json +++ b/package.json @@ -23,6 +23,7 @@ "morgan": "^1.10.0", "multer": "^1.4.5-lts.1", "mysql2": "^3.11.4", + "node-cron": "^3.0.3", "passport": "^0.7.0", "passport-google-oauth20": "^2.0.0", "sequelize": "^6.37.5", diff --git a/routes/friend.js b/routes/friend.js index 782540b23a393a1d00e4b74ceb5db371c542088d..53145a9930403881d542d7fad15a27d9d485edbc 100644 --- a/routes/friend.js +++ b/routes/friend.js @@ -9,7 +9,7 @@ router.use(isLoggedIn); * 친구 요청 보내기 * POST /api/friend/request/:friendId */ -router.post('/request/:friendId', FriendController.sendRequest); +router.post('/request/:friendId', FriendController.sendFriendRequest); /** * 받은 친구 요청 목록 조회 diff --git a/routes/index.js b/routes/index.js deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/routes/schedule.js b/routes/schedule.js index 045bc48e689f139cd72f111ecb76ff3bbe71f508..35da45e5004555891dc1baf16e8cd53d7982d6fb 100644 --- a/routes/schedule.js +++ b/routes/schedule.js @@ -1,6 +1,6 @@ const express = require('express'); const router = express.Router(); -const { isLoggedIn } = require('../middleware/auth'); +const { isLoggedIn } = require('../middlewares/auth'); const ScheduleController = require('../controllers/scheduleController'); /** diff --git a/test/friendService.test.js b/test/friendService.test.js new file mode 100644 index 0000000000000000000000000000000000000000..ca18666c14fb343a97b406a618e1b481595a09a8 --- /dev/null +++ b/test/friendService.test.js @@ -0,0 +1,220 @@ +// test/friendService.test.js + +const sequelize = require('../config/sequelize'); // Sequelize 인스턴스 임포트 +const User = require('../models/User'); +const Friend = require('../models/Friend'); +const friendService = require('../services/friendService'); // FriendService 임포트 + +// Sequelize의 Op를 가져오기 위해 추가 +const { Op } = require('sequelize'); + +beforeAll(async () => { + // 테스트 전에 데이터베이스를 동기화하고 테이블을 생성합니다. + await sequelize.sync({ force: true }); +}); + +beforeEach(async () => { + // 각 테스트 전에 데이터베이스를 초기화하여 독립성을 보장합니다. + await sequelize.sync({ force: true }); + + // 더미 사용자 생성 + await User.bulkCreate([ + { id: 1, name: 'Alice', email: 'alice@example.com' }, + { id: 2, name: 'Bob', email: 'bob@example.com' }, + { id: 3, name: 'Charlie', email: 'charlie@example.com' }, + ]); +}); + +afterAll(async () => { + // 모든 테스트가 끝난 후 데이터베이스 연결을 종료합니다. + await sequelize.close(); +}); + +describe('Friend Service', () => { + describe('validUser', () => { + test('should return user when user exists', async () => { + const user = await friendService.validUser(1); + expect(user).toBeDefined(); + expect(user.name).toBe('Alice'); + }); + + test('should throw error when user does not exist', async () => { + await expect(friendService.validUser(999)).rejects.toThrow('User not found'); + }); + }); + + describe('sendFriendRequest', () => { + test('should send a friend request successfully', async () => { + const friendRequest = await friendService.sendFriendRequest(1, 3); // Alice sends request to Charlie + expect(friendRequest).toBeDefined(); + expect(friendRequest.requester_id).toBe(1); + expect(friendRequest.receiver_id).toBe(3); + expect(friendRequest.status).toBe('PENDING'); + }); + + test('should throw error when sending friend request to self', async () => { + await expect(friendService.sendFriendRequest(1, 1)).rejects.toThrow('Cannot send friend request to yourself'); + }); + + test('should throw error when sending duplicate friend request', async () => { + + await friendService.sendFriendRequest(1, 2); + + + await friendService.acceptFriendRequest(2, 1); + + await expect(friendService.sendFriendRequest(1, 2)).rejects.toThrow('Friend request already exists'); + }); + + test('should throw error when user does not exist', async () => { + await expect(friendService.sendFriendRequest(1, 999)).rejects.toThrow('User not found'); + await expect(friendService.sendFriendRequest(999, 1)).rejects.toThrow('User not found'); + }); + }); + + describe('getReceivedRequests', () => { + test('friend requests', async () => { + await friendService.sendFriendRequest(3, 1); + + const receivedRequests = await friendService.getReceivedRequests(1); + expect(receivedRequests.length).toBe(1); + expect(receivedRequests[0].requester.name).toBe('Charlie'); + }); + + test('not send request', async () => { + const receivedRequests = await friendService.getReceivedRequests(2); + expect(receivedRequests.length).toBe(0); + }); + }); + + describe('getSentRequests', () => { + test('should retrieve sent friend requests', async () => { + + await friendService.sendFriendRequest(1, 3); + + const sentRequests = await friendService.getSentRequests(1); + expect(sentRequests.length).toBe(1); + expect(sentRequests[0].receiver.name).toBe('Charlie'); + }); + + test('should return empty array when no sent requests', async () => { + const sentRequests = await friendService.getSentRequests(3); // Charlie has not sent any PENDING requests + expect(sentRequests.length).toBe(0); + }); + }); + + describe('acceptFriendRequest', () => { + test('should accept a pending friend request successfully', async () => { + + await friendService.sendFriendRequest(3, 1); + + const updatedRequest = await friendService.acceptFriendRequest(1, 3); + expect(updatedRequest).toBeDefined(); + expect(updatedRequest.status).toBe('ACCEPTED'); + + //Db상태 확인 + const request = await Friend.findOne({ + where: { + requester_id: 3, + receiver_id: 1, + }, + }); + expect(request.status).toBe('ACCEPTED'); + }); + + test('없는 요청수락', async () => { + await expect(friendService.acceptFriendRequest(1, 999)).rejects.toThrow('Friend request not found'); + }); + }); + + describe('rejectFriendRequest', () => { + test('should reject a pending friend request successfully', async () => { + + await friendService.sendFriendRequest(2, 3); + + + const result = await friendService.rejectFriendRequest(3, 2); + expect(result).toBe(1); + + const request = await Friend.findOne({ + where: { + requester_id: 2, + receiver_id: 3, + }, + }); + expect(request).toBeNull(); + }); + + test('should throw error when rejecting non-existing friend request', async () => { + await expect(friendService.rejectFriendRequest(1, 999)).rejects.toThrow('Friend request not found'); + }); + }); + + describe('getFriendList', () => { + test('should retrieve friend list with correct pagination', async () => { + await friendService.sendFriendRequest(1, 2); + await friendService.acceptFriendRequest(2, 1); + + await friendService.sendFriendRequest(1, 3); + await friendService.acceptFriendRequest(3, 1); + + // 추가 더미데이터 생성 + for (let i = 4; i <= 23; i++) { + // Create dummy users + await User.create({ + id: i, + name: `User${i}`, + email: `user${i}@example.com`, + }); + + //Alice랑 친구맺기 + await friendService.sendFriendRequest(1, i); + await friendService.acceptFriendRequest(i, 1); + } + + // Alice 친구: Bob (2), Charlie (3),User4 to User23 (20 friends) + const limit = 5; + const offset = 0; + const friendsPage1 = await friendService.getFriendList(1, limit, offset); + expect(friendsPage1.length).toBe(limit); + expect(['Bob', 'Charlie', 'User4', 'User5', 'User6']).toContain(friendsPage1[0].friendInfo.name); + + const friendsPage2 = await friendService.getFriendList(1, limit, limit); + expect(friendsPage2.length).toBe(limit); + expect(['User7', 'User8', 'User9', 'User10', 'User11']).toContain(friendsPage2[0].friendInfo.name); + }); + + test('should return empty array when user has no friends', async () => { + const friends = await friendService.getFriendList(999); // Non-existing user + expect(friends.length).toBe(0); + }); + }); + + describe('deleteFriend', () => { + test('should delete an existing friend relationship successfully', async () => { + + await friendService.sendFriendRequest(1, 2); + await friendService.acceptFriendRequest(2, 1); + + + const result = await friendService.deleteFriend(1, 2); + expect(result).toBe(1); + + + const relationship = await Friend.findOne({ + where: { + [Op.or]: [ + { requester_id: 1, receiver_id: 2 }, + { requester_id: 2, receiver_id: 1 }, + ], + status: 'ACCEPTED', + }, + }); + expect(relationship).toBeNull(); + }); + + test('should throw error when deleting a non-existing friend relationship', async () => { + await expect(friendService.deleteFriend(1, 999)).rejects.toThrow('Friend relationship not found'); + }); + }); +}); diff --git a/test/friendrelation.test.js b/test/friendrelation.test.js new file mode 100644 index 0000000000000000000000000000000000000000..04a2601b50d9554dcdeba6065b3673a6fd5c3205 --- /dev/null +++ b/test/friendrelation.test.js @@ -0,0 +1,133 @@ +// test/friend.test.js + +const sequelize = require('../config/sequelize'); // 환경 변수에 따라 다른 인스턴스 사용 +const User = require('../models/User'); +const Friend = require('../models/Friend'); + +beforeAll(async () => { + // 데이터베이스 동기화 + await sequelize.sync({ force: true }); + + // 더미 사용자 생성 + await User.bulkCreate([ + { id: 1, name: 'Alice', email: 'alice@example.com' }, + { id: 2, name: 'Bob', email: 'bob@example.com' }, + ]); + + // 더미 친구 관계 생성 + await Friend.create({ + id: 1, + requester_id: 1, + receiver_id: 2, + status: 'ACCEPTED', + }); +}); + +afterAll(async () => { + // 데이터베이스 연결 종료 + await sequelize.close();//sequelize.close(): 테스트가 끝난 후 데이터베이스 연결을 종료하여 리소스를 해제 +}); + +describe('User and Friend Relationships', () => { + test('relation mapping test ', async () => { + // 사용자 Alice의 보낸 친구 요청 조회 + const alice = await User.findByPk(1, { + include: { + model: Friend, + as: 'sentRequests', + include: { + model: User, + as: 'receiver', + attributes: ['id', 'name', 'email'], + }, + }, + }); + + expect(alice.sentRequests.length).toBe(1); + expect(alice.sentRequests[0].receiver.name).toBe('Bob'); + + // 사용자 Bob의 받은 친구 요청 조회 + const bob = await User.findByPk(2, { + include: { + model: Friend, + as: 'receivedRequests', + include: { + model: User, + as: 'requester', + attributes: ['id', 'name', 'email'], + }, + }, + }); + + expect(bob.receivedRequests.length).toBe(1); + expect(bob.receivedRequests[0].requester.name).toBe('Alice'); + }); + + test('create friend', async () => { + // 새로운 친구 요청 생성 + const newFriendRequest = await Friend.create({ + id: 2, + requester_id: 2, + receiver_id: 1, + status: 'PENDING', + }); + + expect(newFriendRequest.requester_id).toBe(2); + expect(newFriendRequest.receiver_id).toBe(1); + expect(newFriendRequest.status).toBe('PENDING'); + + // 사용자 Bob의 보낸 친구 요청 조회 + const bob = await User.findByPk(2, { + include: { + model: Friend, + as: 'sentRequests', + where: { id: 2 }, + include: { + model: User, + as: 'receiver', + attributes: ['id', 'name', 'email'], + }, + }, + }); + + expect(bob.sentRequests.length).toBe(1); + expect(bob.sentRequests[0].receiver.name).toBe('Alice'); + }); + + test('self friend reqeust', async () => { + await expect( + Friend.create({ + id: 3, + requester_id: 1, + receiver_id: 1, // 자신에게 요청 + status: 'PENDING', + }) + ).rejects.toThrow(); + }); + + test('already request test', async () => { + // Alice가 Bob에게 이미 친구 요청을 보냈으므로, 다시 보내면 에러 발생 + await expect( + Friend.create({ + id: 4, + requester_id: 1, + receiver_id: 2, + status: 'PENDING', + }) + ).rejects.toThrow(); + }); + + test('should accept a pending friend request correctly', async () => { + // Bob이 Alice에게 보낸 친구 요청을 'ACCEPTED' 상태로 변경 + const friendRequest = await Friend.findOne({ where: { id: 2 } }); + expect(friendRequest.status).toBe('PENDING'); + + friendRequest.status = 'ACCEPTED'; + await friendRequest.save(); + + const updatedRequest = await Friend.findOne({ where: { id: 2 } }); + expect(updatedRequest.status).toBe('ACCEPTED'); + }); + + +}); diff --git a/test/schedule.test.js b/test/schedule.test.js new file mode 100644 index 0000000000000000000000000000000000000000..a82562bf124a1f5044e3ecf54990531527bff78d --- /dev/null +++ b/test/schedule.test.js @@ -0,0 +1,233 @@ +// test/schedule.test.js + +const sequelize = require('../config/sequelize'); +const User = require('../models/User'); +const Friend = require('../models/Friend'); +const Schedule = require('../models/Schedule'); +const scheduleService = require('../services/scheduleService'); // scheduleService 임포트 + +beforeAll(async () => { + await sequelize.sync({ force: true }); + // 더미 사용자 생성 + await User.bulkCreate([ + { id: 1, name: 'Alice', email: 'alice@example.com' }, + { id: 2, name: 'Bob', email: 'bob@example.com' }, + ]); + + // 더미 친구 관계 생성 + await Friend.create({ + id: 1, + requester_id: 1, + receiver_id: 2, + status: 'ACCEPTED', + }); + + // 더미 스케줄 생성 + await Schedule.create({ + id: 1, + user_id: 1, + title: 'Alice\'s Fixed Schedule', + start_time: new Date('2024-05-01T09:00:00Z'), + end_time: new Date('2024-05-01T10:00:00Z'), + is_fixed: true, + expiry_date: null, + }); + + await Schedule.create({ + id: 2, + user_id: 1, + title: 'Alice\'s Flexible Schedule', + start_time: new Date('2024-05-02T11:00:00Z'), + end_time: new Date('2024-05-02T12:00:00Z'), + is_fixed: false, + expiry_date: new Date('2024-05-08T00:00:00Z'), // 다음 월요일 + }); +}); + +afterAll(async () => { + // 데이터베이스 연결 종료 + await sequelize.close(); +}); + +describe('Schedule Service', () => { + describe('createSchedule', () => { + test('should create a new fixed schedule successfully', async () => { + const scheduleData = { + userId: 2, + title: 'Bob\'s Fixed Schedule', + start_time: new Date('2024-05-03T14:00:00Z'), + end_time: new Date('2024-05-03T15:00:00Z'), + is_fixed: true, + }; + + const schedule = await scheduleService.createSchedule(scheduleData); + + expect(schedule).toBeDefined(); + expect(schedule.user_id).toBe(2); + expect(schedule.title).toBe('Bob\'s Fixed Schedule'); + expect(schedule.is_fixed).toBe(true); + expect(schedule.expiry_date).toBeNull(); + }); + + test('should create a new flexible schedule with expiry date', async () => { + const scheduleData = { + userId: 2, + title: 'Bob\'s Flexible Schedule', + start_time: new Date('2024-05-04T16:00:00Z'), + end_time: new Date('2024-05-04T17:00:00Z'), + is_fixed: false, + }; + + const schedule = await scheduleService.createSchedule(scheduleData); + + expect(schedule).toBeDefined(); + expect(schedule.user_id).toBe(2); + expect(schedule.title).toBe('Bob\'s Flexible Schedule'); + expect(schedule.is_fixed).toBe(false); + expect(schedule.expiry_date).toBeInstanceOf(Date); + + // expiry_date가 다음 월요일로 설정되었는지 확인 + const expectedExpiryDate = new Date('2024-05-06T00:00:00Z'); // 2024-05-06은 다음 월요일 + expect(schedule.expiry_date.toISOString()).toBe(expectedExpiryDate.toISOString()); + }); + + test('should throw error when schedule times overlap with existing schedule', async () => { + const scheduleData = { + userId: 1, + title: 'Alice\'s Overlapping Schedule', + start_time: new Date('2024-05-01T09:30:00Z'), // 기존 스케줄과 겹침 + end_time: new Date('2024-05-01T10:30:00Z'), + is_fixed: false, + }; + + await expect(scheduleService.createSchedule(scheduleData)).rejects.toThrow('Schedule overlaps with existing schedule'); + }); + + test('should throw error when start_time is after end_time', async () => { + const scheduleData = { + userId: 1, + title: 'Invalid Schedule', + start_time: new Date('2024-05-05T18:00:00Z'), + end_time: new Date('2024-05-05T17:00:00Z'), // start_time이 더 나중 + is_fixed: false, + }; + + await expect(scheduleService.createSchedule(scheduleData)).rejects.toThrow('Start time must be before end time'); + }); + }); + + describe('updateSchedule', () => { + test('should update an existing schedule successfully', async () => { + const updateData = { + title: 'Alice\'s Updated Flexible Schedule', + start_time: new Date('2024-05-02T11:30:00Z'), + end_time: new Date('2024-05-02T12:30:00Z'), + }; + + const updatedSchedule = await scheduleService.updateSchedule(2, 1, updateData); + + expect(updatedSchedule).toBeDefined(); + expect(updatedSchedule.title).toBe('Alice\'s Updated Flexible Schedule'); + expect(updatedSchedule.start_time.toISOString()).toBe(new Date('2024-05-02T11:30:00Z').toISOString()); + expect(updatedSchedule.end_time.toISOString()).toBe(new Date('2024-05-02T12:30:00Z').toISOString()); + expect(updatedSchedule.expiry_date).toBeInstanceOf(Date); + }); + + test('should throw error when updating a non-existing schedule', async () => { + const updateData = { + title: 'Non-existing Schedule', + start_time: new Date('2024-05-06T10:00:00Z'), + end_time: new Date('2024-05-06T11:00:00Z'), + }; + + await expect(scheduleService.updateSchedule(999, 1, updateData)).rejects.toThrow('Schedule not found'); + }); + + test('should throw error when updated schedule overlaps with existing schedule', async () => { + const updateData = { + title: 'Alice\'s Overlapping Update', + start_time: new Date('2024-05-01T09:30:00Z'), // 기존 스케줄과 겹침 + end_time: new Date('2024-05-01T10:30:00Z'), + }; + + await expect(scheduleService.updateSchedule(2, 1, updateData)).rejects.toThrow('Schedule overlaps with existing schedule'); + }); + }); + + describe('deleteSchedule', () => { + test('should delete an existing schedule successfully', async () => { + const result = await scheduleService.deleteSchedule(2, 1); + + expect(result).toBe(true); + + // 삭제된 스케줄이 실제로 삭제되었는지 확인 + const schedule = await Schedule.findByPk(2); + expect(schedule).toBeNull(); + }); + + test('should throw error when deleting a non-existing schedule', async () => { + await expect(scheduleService.deleteSchedule(999, 1)).rejects.toThrow('Schedule not found'); + }); + }); + + describe('getAllSchedules', () => { + test('should retrieve all valid schedules for a user', async () => { + // 사용자 Alice의 모든 스케줄 조회 + const schedules = await scheduleService.getAllSchedules(1); + + expect(schedules.length).toBe(1); // id=1 스케줄은 is_fixed=true + expect(schedules[0].title).toBe('Alice\'s Fixed Schedule'); + }); + }); + + describe('getScheduleById', () => { + test('should retrieve a specific schedule by ID', async () => { + const schedule = await scheduleService.getScheduleById(1, 1); + + expect(schedule).toBeDefined(); + expect(schedule.title).toBe('Alice\'s Fixed Schedule'); + }); + + test('should throw error when retrieving a non-existing schedule', async () => { + await expect(scheduleService.getScheduleById(999, 1)).rejects.toThrow('Schedule not found'); + }); + }); + + describe('cleanExpiredSchedules', () => { + test('should delete expired flexible schedules', async () => { + // 만료된 유동 스케줄 생성 + await Schedule.create({ + id: 3, + user_id: 1, + title: 'Expired Flexible Schedule', + start_time: new Date('2024-04-25T10:00:00Z'), + end_time: new Date('2024-04-25T11:00:00Z'), + is_fixed: false, + expiry_date: new Date('2024-04-30T00:00:00Z'), // 이미 만료됨 + }); + + // 만료되지 않은 유동 스케줄 생성 + await Schedule.create({ + id: 4, + user_id: 1, + title: 'Valid Flexible Schedule', + start_time: new Date('2024-05-07T10:00:00Z'), + end_time: new Date('2024-05-07T11:00:00Z'), + is_fixed: false, + expiry_date: new Date('2024-05-14T00:00:00Z'), // 아직 만료되지 않음 + }); + + // 만료된 스케줄 정리 + await scheduleService.cleanExpiredSchedules(); + + // 만료된 스케줄이 삭제되었는지 확인 + const expiredSchedule = await Schedule.findByPk(3); + expect(expiredSchedule).toBeNull(); + + // 만료되지 않은 스케줄은 남아있는지 확인 + const validSchedule = await Schedule.findByPk(4); + expect(validSchedule).toBeDefined(); + expect(validSchedule.title).toBe('Valid Flexible Schedule'); + }); + }); +});