tududi/backend/tests/integration/users.test.js

const request = require('supertest');
const app = require('../../app');
const { User } = require('../../models');
const { createTestUser } = require('../helpers/testUtils');

describe('Users Routes', () => {
  let user, agent;

  beforeEach(async () => {
    user = await createTestUser({
      email: 'test@example.com'
    });

    // Create authenticated agent
    agent = request.agent(app);
    await agent
      .post('/api/login')
      .send({
        email: 'test@example.com',
        password: 'password123'
      });
  });

  describe('GET /api/profile', () => {
    it('should get user profile', async () => {
      const response = await agent.get('/api/profile');

      expect(response.status).toBe(200);
      expect(response.body.id).toBe(user.id);
      expect(response.body.email).toBe(user.email);
      expect(response.body).toHaveProperty('appearance');
      expect(response.body).toHaveProperty('language');
      expect(response.body).toHaveProperty('timezone');
      expect(response.body).toHaveProperty('avatar_image');
      expect(response.body).toHaveProperty('telegram_bot_token');
      expect(response.body).toHaveProperty('telegram_chat_id');
      expect(response.body).toHaveProperty('task_summary_enabled');
      expect(response.body).toHaveProperty('task_summary_frequency');
    });

    it('should require authentication', async () => {
      const response = await request(app).get('/api/profile');

      expect(response.status).toBe(401);
      expect(response.body.error).toBe('Authentication required');
    });

    it('should return 401 when session user no longer exists', async () => {
      await User.destroy({ where: { id: user.id } });

      const response = await agent.get('/api/profile');

      expect(response.status).toBe(401);
      expect(response.body.error).toBe('User not found');
    });
  });

  describe('PATCH /api/profile', () => {
    it('should update user profile', async () => {
      const updateData = {
        appearance: 'dark',
        language: 'es',
        timezone: 'UTC',
        avatar_image: 'new-avatar.png',
        telegram_bot_token: 'new-token'
      };

      const response = await agent
        .patch('/api/profile')
        .send(updateData);

      expect(response.status).toBe(200);
      expect(response.body.appearance).toBe(updateData.appearance);
      expect(response.body.language).toBe(updateData.language);
      expect(response.body.timezone).toBe(updateData.timezone);
      expect(response.body.avatar_image).toBe(updateData.avatar_image);
      expect(response.body.telegram_bot_token).toBe(updateData.telegram_bot_token);
    });

    it('should allow partial updates', async () => {
      const updateData = {
        appearance: 'dark'
      };

      const response = await agent
        .patch('/api/profile')
        .send(updateData);

      expect(response.status).toBe(200);
      expect(response.body.appearance).toBe(updateData.appearance);
      expect(response.body.language).toBe(user.language);
    });

    it('should require authentication', async () => {
      const updateData = {
        appearance: 'dark'
      };

      const response = await request(app)
        .patch('/api/profile')
        .send(updateData);

      expect(response.status).toBe(401);
      expect(response.body.error).toBe('Authentication required');
    });

    it('should return 401 when session user no longer exists', async () => {
      await User.destroy({ where: { id: user.id } });

      const response = await agent
        .patch('/api/profile')
        .send({ appearance: 'dark' });

      expect(response.status).toBe(401);
      expect(response.body.error).toBe('User not found');
    });
  });

  describe('POST /api/profile/task-summary/toggle', () => {
    beforeEach(async () => {
      await user.update({ task_summary_enabled: false });
    });

    it('should toggle task summary on', async () => {
      const response = await agent.post('/api/profile/task-summary/toggle');

      expect(response.status).toBe(200);
      expect(response.body.success).toBe(true);
      expect(response.body.enabled).toBe(true);
      expect(response.body.message).toBe('Task summary notifications have been enabled.');
    });

    it('should toggle task summary off', async () => {
      await user.update({ task_summary_enabled: true });

      const response = await agent.post('/api/profile/task-summary/toggle');

      expect(response.status).toBe(200);
      expect(response.body.success).toBe(true);
      expect(response.body.enabled).toBe(false);
      expect(response.body.message).toBe('Task summary notifications have been disabled.');
    });

    it('should require authentication', async () => {
      const response = await request(app).post('/api/profile/task-summary/toggle');

      expect(response.status).toBe(401);
      expect(response.body.error).toBe('Authentication required');
    });

    it('should return 401 when session user no longer exists', async () => {
      await User.destroy({ where: { id: user.id } });

      const response = await agent.post('/api/profile/task-summary/toggle');

      expect(response.status).toBe(401);
      expect(response.body.error).toBe('User not found');
    });
  });

  describe('POST /api/profile/task-summary/frequency', () => {
    it('should update task summary frequency', async () => {
      const response = await agent
        .post('/api/profile/task-summary/frequency')
        .send({ frequency: 'daily' });

      expect(response.status).toBe(200);
      expect(response.body.success).toBe(true);
      expect(response.body.frequency).toBe('daily');
      expect(response.body.message).toBe('Task summary frequency has been set to daily.');
    });

    it('should require frequency parameter', async () => {
      const response = await agent
        .post('/api/profile/task-summary/frequency')
        .send({});

      expect(response.status).toBe(400);
      expect(response.body.error).toBe('Frequency is required.');
    });

    it('should validate frequency value', async () => {
      const response = await agent
        .post('/api/profile/task-summary/frequency')
        .send({ frequency: 'invalid' });

      expect(response.status).toBe(400);
      expect(response.body.error).toBe('Invalid frequency value.');
    });

    it('should accept valid frequencies', async () => {
      const validFrequencies = ['daily', 'weekdays', 'weekly', '1h', '2h', '4h', '8h', '12h'];
      
      for (const frequency of validFrequencies) {
        const response = await agent
          .post('/api/profile/task-summary/frequency')
          .send({ frequency });

        expect(response.status).toBe(200);
        expect(response.body.frequency).toBe(frequency);
      }
    });

    it('should require authentication', async () => {
      const response = await request(app)
        .post('/api/profile/task-summary/frequency')
        .send({ frequency: 'daily' });

      expect(response.status).toBe(401);
      expect(response.body.error).toBe('Authentication required');
    });

    it('should return 401 when session user no longer exists', async () => {
      await User.destroy({ where: { id: user.id } });

      const response = await agent
        .post('/api/profile/task-summary/frequency')
        .send({ frequency: 'daily' });

      expect(response.status).toBe(401);
      expect(response.body.error).toBe('User not found');
    });
  });

  describe('POST /api/profile/task-summary/send-now', () => {
    it('should require telegram configuration', async () => {
      const response = await agent.post('/api/profile/task-summary/send-now');

      expect(response.status).toBe(400);
      expect(response.body.error).toBe('Telegram bot is not properly configured.');
    });

    it('should require authentication', async () => {
      const response = await request(app).post('/api/profile/task-summary/send-now');

      expect(response.status).toBe(401);
      expect(response.body.error).toBe('Authentication required');
    });

    it('should return 401 when session user no longer exists', async () => {
      await User.destroy({ where: { id: user.id } });

      const response = await agent.post('/api/profile/task-summary/send-now');

      expect(response.status).toBe(401);
      expect(response.body.error).toBe('User not found');
    });
  });

  describe('GET /api/profile/task-summary/status', () => {
    it('should get task summary status', async () => {
      await user.update({
        task_summary_enabled: true,
        task_summary_frequency: 'daily'
      });

      const response = await agent.get('/api/profile/task-summary/status');

      expect(response.status).toBe(200);
      expect(response.body.success).toBe(true);
      expect(response.body.enabled).toBe(true);
      expect(response.body.frequency).toBe('daily');
      expect(response.body).toHaveProperty('last_run');
      expect(response.body).toHaveProperty('next_run');
    });

    it('should require authentication', async () => {
      const response = await request(app).get('/api/profile/task-summary/status');

      expect(response.status).toBe(401);
      expect(response.body.error).toBe('Authentication required');
    });

    it('should return 401 when session user no longer exists', async () => {
      await User.destroy({ where: { id: user.id } });

      const response = await agent.get('/api/profile/task-summary/status');

      expect(response.status).toBe(401);
      expect(response.body.error).toBe('User not found');
    });
  });
});