adopt-a-street/backend/__tests__/routes/rewards.test.js

const request = require('supertest');
const express = require('express');

// Mock CouchDB service before importing routes
jest.mock('../../services/couchdbService', () => ({
  initialize: jest.fn().mockResolvedValue(true),
  create: jest.fn(),
  getById: jest.fn(),
  find: jest.fn(),
  createDocument: jest.fn(),
  updateDocument: jest.fn(),
  deleteDocument: jest.fn(),
  findByType: jest.fn(),
  findUserById: jest.fn(),
  update: jest.fn(),
}));

const rewardsRoutes = require('../../routes/rewards');
const Reward = require('../../models/Reward');
const User = require('../../models/User');
const { createTestUser, createTestReward } = require('../utils/testHelpers');
const couchdbService = require('../../services/couchdbService');

// Create Express app for testing
const app = express();
app.use(express.json());
app.use('/api/rewards', rewardsRoutes);

describe('Rewards Routes', () => {
  beforeEach(() => {
    jest.clearAllMocks();
  });
  describe('GET /api/rewards', () => {
    it('should get all rewards', async () => {
      await createTestReward({ name: 'Reward 1', pointsCost: 50 });
      await createTestReward({ name: 'Reward 2', pointsCost: 100 });

      const response = await request(app)
        .get('/api/rewards')
        .expect(200);

      expect(Array.isArray(response.body)).toBe(true);
      expect(response.body.length).toBe(2);
      expect(response.body[0]).toHaveProperty('name');
      expect(response.body[0]).toHaveProperty('pointsCost');
    });

    it('should return empty array when no rewards exist', async () => {
      const response = await request(app)
        .get('/api/rewards')
        .expect(200);

      expect(Array.isArray(response.body)).toBe(true);
      expect(response.body.length).toBe(0);
    });
  });

  describe('POST /api/rewards', () => {
    it('should create a new reward with authentication', async () => {
      const { token } = await createTestUser();
      const rewardData = {
        name: 'New Badge',
        description: 'A shiny new badge',
        cost: 150,
        isPremium: false,
      };

      const response = await request(app)
        .post('/api/rewards')
        .set('x-auth-token', token)
        .send(rewardData)
        .expect(200);

      expect(response.body).toHaveProperty('_id');
      expect(response.body.name).toBe(rewardData.name);
      expect(response.body.description).toBe(rewardData.description);

      // Verify reward was created in database
      const reward = await Reward.findById(response.body._id);
      expect(reward).toBeTruthy();
      expect(reward.name).toBe(rewardData.name);
    });

    it('should reject reward creation without authentication', async () => {
      const rewardData = {
        name: 'Unauthorized Reward',
        description: 'This should fail',
        cost: 100,
      };

      const response = await request(app)
        .post('/api/rewards')
        .send(rewardData)
        .expect(401);

      expect(response.body).toHaveProperty('msg', 'No token, authorization denied');
    });
  });

  describe('POST /api/rewards/redeem/:id', () => {
    it('should allow user to redeem reward with sufficient points', async () => {
      const { user, token } = await createTestUser();

      // Give user enough points
      await User.findByIdAndUpdate(user.id, { points: 200 });

      const reward = await createTestReward({
        name: 'Test Reward',
        pointsCost: 100,
        isPremium: false
      });

      const response = await request(app)
        .post(`/api/rewards/redeem/${reward.id}`)
        .set('x-auth-token', token)
        .expect(200);

      expect(response.body).toHaveProperty('msg', 'Reward redeemed successfully');

      // Verify user points were deducted
      const updatedUser = await User.findById(user.id);
      expect(updatedUser.points).toBe(100); // 200 - 100
    });

    it('should reject redemption without sufficient points', async () => {
      const { user, token } = await createTestUser();

      // User has 0 points by default
      const reward = await createTestReward({
        name: 'Expensive Reward',
        pointsCost: 100
      });

      const response = await request(app)
        .post(`/api/rewards/redeem/${reward.id}`)
        .set('x-auth-token', token)
        .expect(400);

      expect(response.body).toHaveProperty('msg', 'Not enough points');
    });

    it('should reject premium reward redemption for non-premium users', async () => {
      const { user, token } = await createTestUser();

      // Give user enough points but not premium status
      await User.findByIdAndUpdate(user.id, { points: 500 });

      const reward = await createTestReward({
        name: 'Premium Reward',
        pointsCost: 100,
        isPremium: true
      });

      const response = await request(app)
        .post(`/api/rewards/redeem/${reward.id}`)
        .set('x-auth-token', token)
        .expect(403);

      expect(response.body).toHaveProperty('msg', 'Premium reward not available');
    });

    it('should allow premium users to redeem premium rewards', async () => {
      const { user, token } = await createTestUser();

      // Give user points and premium status
      await User.findByIdAndUpdate(user.id, { points: 500, isPremium: true });

      const reward = await createTestReward({
        name: 'Premium Reward',
        pointsCost: 100,
        isPremium: true
      });

      const response = await request(app)
        .post(`/api/rewards/redeem/${reward.id}`)
        .set('x-auth-token', token)
        .expect(200);

      expect(response.body).toHaveProperty('msg', 'Reward redeemed successfully');

      // Verify user points were deducted
      const updatedUser = await User.findById(user.id);
      expect(updatedUser.points).toBe(400); // 500 - 100
    });

    it('should return 404 for non-existent reward', async () => {
      const { user, token } = await createTestUser();
      await User.findByIdAndUpdate(user.id, { points: 500 });

      const fakeId = '507f1f77bcf86cd799439011';

      const response = await request(app)
        .post(`/api/rewards/redeem/${fakeId}`)
        .set('x-auth-token', token)
        .expect(404);

      expect(response.body).toHaveProperty('msg', 'Reward not found');
    });

    it('should reject redemption without authentication', async () => {
      const reward = await createTestReward();

      const response = await request(app)
        .post(`/api/rewards/redeem/${reward.id}`)
        .expect(401);

      expect(response.body).toHaveProperty('msg', 'No token, authorization denied');
    });

    it('should handle invalid reward ID format', async () => {
      const { token } = await createTestUser();

      const response = await request(app)
        .post('/api/rewards/redeem/invalid-id')
        .set('x-auth-token', token)
        .expect(500);

      expect(response.body).toBeDefined();
    });
  });
});