Spaces:
Paused
Paused
| ; | |
| /** | |
| * Feedback Controller Unit Tests | |
| * Tests for feedback event endpoints | |
| */ | |
| // Mock dependencies before requiring the controller | |
| const mockPool = { | |
| query: jest.fn(), | |
| connect: jest.fn(() => ({ | |
| query: jest.fn(), | |
| release: jest.fn() | |
| })) | |
| }; | |
| jest.mock('../src/db', () => ({ | |
| getPool: jest.fn(() => mockPool) | |
| })); | |
| jest.mock('uuid', () => ({ | |
| v4: jest.fn(() => 'mock-uuid-1234') | |
| })); | |
| const feedbackController = require('../src/controllers/feedback.controller'); | |
| const { getPool } = require('../src/db'); | |
| describe('Feedback Controller', () => { | |
| let mockReq; | |
| let mockRes; | |
| let mockPool; | |
| beforeEach(() => { | |
| mockReq = { | |
| body: {}, | |
| query: {}, | |
| params: {} | |
| }; | |
| mockRes = { | |
| status: jest.fn().mockReturnThis(), | |
| json: jest.fn().mockReturnThis() | |
| }; | |
| mockPool = getPool(); | |
| jest.clearAllMocks(); | |
| }); | |
| describe('createFeedbackEvent', () => { | |
| it('should return 400 if event_type is missing', async () => { | |
| mockReq.body = { session_id: 'session-1' }; | |
| await feedbackController.createFeedbackEvent(mockReq, mockRes); | |
| expect(mockRes.status).toHaveBeenCalledWith(400); | |
| expect(mockRes.json).toHaveBeenCalledWith({ | |
| error: { message: 'event_type is required' } | |
| }); | |
| }); | |
| it('should return 400 for invalid event_type', async () => { | |
| mockReq.body = { event_type: 'invalid_type' }; | |
| await feedbackController.createFeedbackEvent(mockReq, mockRes); | |
| expect(mockRes.status).toHaveBeenCalledWith(400); | |
| expect(mockRes.json).toHaveBeenCalledWith( | |
| expect.objectContaining({ | |
| error: expect.objectContaining({ | |
| message: expect.stringContaining('Invalid event_type') | |
| }) | |
| }) | |
| ); | |
| }); | |
| it('should accept all valid event types', async () => { | |
| const validEventTypes = [ | |
| 'plan_saved', 'plan_completed', 'rating_positive', | |
| 'poi_added', 'plan_abandoned', 'poi_removed', | |
| 'rating_negative', 'poi_reordered', 'poi_swapped', 'session_start' | |
| ]; | |
| for (const eventType of validEventTypes) { | |
| mockReq.body = { event_type: eventType }; | |
| mockPool.query.mockResolvedValueOnce({}); | |
| await feedbackController.createFeedbackEvent(mockReq, mockRes); | |
| // Reset for next iteration | |
| jest.clearAllMocks(); | |
| mockPool = getPool(); | |
| } | |
| }); | |
| it('should create a feedback event successfully', async () => { | |
| mockReq.body = { | |
| event_type: 'plan_saved', | |
| session_id: 'session-123', | |
| user_hash: 'user-hash-456', | |
| context: { destination: 'Ranchi' }, | |
| itinerary_snapshot: [{ poi_id: 'poi-1', name: 'Hundru Falls' }], | |
| modifications: [], | |
| reward: 1.5 | |
| }; | |
| mockPool.query.mockResolvedValueOnce({}); | |
| await feedbackController.createFeedbackEvent(mockReq, mockRes); | |
| expect(mockRes.status).toHaveBeenCalledWith(201); | |
| expect(mockRes.json).toHaveBeenCalledWith({ | |
| data: expect.objectContaining({ | |
| id: 'mock-uuid-1234', | |
| event_type: 'plan_saved', | |
| session_id: 'session-123', | |
| reward: 1.5 | |
| }), | |
| message: 'Feedback event recorded successfully' | |
| }); | |
| }); | |
| it('should return 503 if database is not available', async () => { | |
| mockReq.body = { event_type: 'plan_saved' }; | |
| // Override getPool to return null | |
| require('../src/db').getPool.mockReturnValueOnce(null); | |
| await feedbackController.createFeedbackEvent(mockReq, mockRes); | |
| expect(mockRes.status).toHaveBeenCalledWith(503); | |
| expect(mockRes.json).toHaveBeenCalledWith({ | |
| error: { message: 'Database not available' } | |
| }); | |
| }); | |
| it('should return 500 on database error', async () => { | |
| mockReq.body = { event_type: 'plan_saved' }; | |
| mockPool.query.mockRejectedValueOnce(new Error('DB connection failed')); | |
| await feedbackController.createFeedbackEvent(mockReq, mockRes); | |
| expect(mockRes.status).toHaveBeenCalledWith(500); | |
| expect(mockRes.json).toHaveBeenCalledWith({ | |
| error: { message: 'Failed to record feedback event' } | |
| }); | |
| }); | |
| it('should use default values for optional fields', async () => { | |
| mockReq.body = { event_type: 'session_start' }; | |
| mockPool.query.mockResolvedValueOnce({}); | |
| await feedbackController.createFeedbackEvent(mockReq, mockRes); | |
| expect(mockPool.query).toHaveBeenCalledWith( | |
| expect.any(String), | |
| expect.arrayContaining([ | |
| 'mock-uuid-1234', | |
| 'session_start', | |
| null, // session_id | |
| null, // user_hash | |
| '{}', // context | |
| '[]', // itinerary_snapshot | |
| '[]', // modifications | |
| 0 // reward | |
| ]) | |
| ); | |
| }); | |
| }); | |
| describe('listFeedbackEvents', () => { | |
| it('should list all feedback events with default pagination', async () => { | |
| const mockEvents = [ | |
| { id: '1', event_type: 'plan_saved' }, | |
| { id: '2', event_type: 'poi_added' } | |
| ]; | |
| mockPool.query.mockResolvedValueOnce({ rows: mockEvents }); | |
| await feedbackController.listFeedbackEvents(mockReq, mockRes); | |
| expect(mockRes.json).toHaveBeenCalledWith({ data: mockEvents }); | |
| }); | |
| it('should filter by event_type', async () => { | |
| mockReq.query = { event_type: 'plan_saved' }; | |
| mockPool.query.mockResolvedValueOnce({ rows: [] }); | |
| await feedbackController.listFeedbackEvents(mockReq, mockRes); | |
| expect(mockPool.query).toHaveBeenCalledWith( | |
| expect.stringContaining('event_type = $'), | |
| expect.arrayContaining(['plan_saved']) | |
| ); | |
| }); | |
| it('should filter by session_id', async () => { | |
| mockReq.query = { session_id: 'session-123' }; | |
| mockPool.query.mockResolvedValueOnce({ rows: [] }); | |
| await feedbackController.listFeedbackEvents(mockReq, mockRes); | |
| expect(mockPool.query).toHaveBeenCalledWith( | |
| expect.stringContaining('session_id = $'), | |
| expect.arrayContaining(['session-123']) | |
| ); | |
| }); | |
| it('should apply custom pagination', async () => { | |
| mockReq.query = { limit: '50', offset: '100' }; | |
| mockPool.query.mockResolvedValueOnce({ rows: [] }); | |
| await feedbackController.listFeedbackEvents(mockReq, mockRes); | |
| expect(mockPool.query).toHaveBeenCalledWith( | |
| expect.any(String), | |
| expect.arrayContaining([50, 100]) | |
| ); | |
| }); | |
| it('should cap limit at 1000', async () => { | |
| mockReq.query = { limit: '5000' }; | |
| mockPool.query.mockResolvedValueOnce({ rows: [] }); | |
| await feedbackController.listFeedbackEvents(mockReq, mockRes); | |
| expect(mockPool.query).toHaveBeenCalledWith( | |
| expect.any(String), | |
| expect.arrayContaining([1000]) | |
| ); | |
| }); | |
| it('should return 503 if database is not available', async () => { | |
| require('../src/db').getPool.mockReturnValueOnce(null); | |
| await feedbackController.listFeedbackEvents(mockReq, mockRes); | |
| expect(mockRes.status).toHaveBeenCalledWith(503); | |
| }); | |
| it('should return 500 on database error', async () => { | |
| mockPool.query.mockRejectedValueOnce(new Error('DB error')); | |
| await feedbackController.listFeedbackEvents(mockReq, mockRes); | |
| expect(mockRes.status).toHaveBeenCalledWith(500); | |
| expect(mockRes.json).toHaveBeenCalledWith({ | |
| error: { message: 'Failed to list feedback events' } | |
| }); | |
| }); | |
| }); | |
| describe('getPOIStats', () => { | |
| it('should return 400 if poi_id is missing', async () => { | |
| mockReq.params = {}; | |
| await feedbackController.getPOIStats(mockReq, mockRes); | |
| expect(mockRes.status).toHaveBeenCalledWith(400); | |
| expect(mockRes.json).toHaveBeenCalledWith({ | |
| error: { message: 'poi_id is required' } | |
| }); | |
| }); | |
| it('should return aggregated stats for a POI', async () => { | |
| mockReq.params = { poi_id: 'poi-123' }; | |
| const mockEvents = [ | |
| { event_type: 'plan_saved', reward: '1.0', modifications: '[]' }, | |
| { event_type: 'plan_saved', reward: '0.5', modifications: '[]' }, | |
| { event_type: 'poi_removed', reward: '-0.5', modifications: '[{"poi_id": "poi-123"}]' } | |
| ]; | |
| mockPool.query.mockResolvedValueOnce({ rows: mockEvents }); | |
| await feedbackController.getPOIStats(mockReq, mockRes); | |
| expect(mockRes.json).toHaveBeenCalledWith({ | |
| data: expect.objectContaining({ | |
| poi_id: 'poi-123', | |
| times_suggested: 3, | |
| times_saved: 2, | |
| times_removed: 1 | |
| }) | |
| }); | |
| }); | |
| it('should calculate save_rate correctly', async () => { | |
| mockReq.params = { poi_id: 'poi-456' }; | |
| const mockEvents = [ | |
| { event_type: 'plan_saved', reward: '1.0', modifications: '[]' }, | |
| { event_type: 'plan_completed', reward: '1.0', modifications: '[]' } | |
| ]; | |
| mockPool.query.mockResolvedValueOnce({ rows: mockEvents }); | |
| await feedbackController.getPOIStats(mockReq, mockRes); | |
| expect(mockRes.json).toHaveBeenCalledWith({ | |
| data: expect.objectContaining({ | |
| times_saved: 1, | |
| times_suggested: 2, | |
| save_rate: '0.50' | |
| }) | |
| }); | |
| }); | |
| it('should return zero stats for POI with no events', async () => { | |
| mockReq.params = { poi_id: 'new-poi' }; | |
| mockPool.query.mockResolvedValueOnce({ rows: [] }); | |
| await feedbackController.getPOIStats(mockReq, mockRes); | |
| expect(mockRes.json).toHaveBeenCalledWith({ | |
| data: expect.objectContaining({ | |
| poi_id: 'new-poi', | |
| times_suggested: 0, | |
| times_saved: 0, | |
| times_removed: 0, | |
| avg_reward: 0, | |
| save_rate: 0 | |
| }) | |
| }); | |
| }); | |
| it('should return 503 if database is not available', async () => { | |
| mockReq.params = { poi_id: 'poi-123' }; | |
| require('../src/db').getPool.mockReturnValueOnce(null); | |
| await feedbackController.getPOIStats(mockReq, mockRes); | |
| expect(mockRes.status).toHaveBeenCalledWith(503); | |
| }); | |
| it('should return 500 on database error', async () => { | |
| mockReq.params = { poi_id: 'poi-123' }; | |
| mockPool.query.mockRejectedValueOnce(new Error('DB error')); | |
| await feedbackController.getPOIStats(mockReq, mockRes); | |
| expect(mockRes.status).toHaveBeenCalledWith(500); | |
| expect(mockRes.json).toHaveBeenCalledWith({ | |
| error: { message: 'Failed to get POI stats' } | |
| }); | |
| }); | |
| }); | |
| }); | |