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

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

describe('Quotes 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/quotes/random', () => {
    it('should return a random quote', async () => {
      const response = await agent
        .get('/api/quotes/random');

      expect(response.status).toBe(200);
      expect(response.body).toHaveProperty('quote');
      expect(typeof response.body.quote).toBe('string');
      expect(response.body.quote.length).toBeGreaterThan(0);
    });

    it('should return different quotes on multiple requests', async () => {
      const responses = await Promise.all([
        agent.get('/api/quotes/random'),
        agent.get('/api/quotes/random'),
        agent.get('/api/quotes/random'),
        agent.get('/api/quotes/random'),
        agent.get('/api/quotes/random')
      ]);

      // All responses should be successful
      responses.forEach(response => {
        expect(response.status).toBe(200);
        expect(response.body).toHaveProperty('quote');
        expect(typeof response.body.quote).toBe('string');
      });

      // With multiple requests, we should get at least some variety
      // (though it's possible to get the same quote multiple times due to randomness)
      const quotes = responses.map(r => r.body.quote);
      const uniqueQuotes = new Set(quotes);
      
      // We expect at least 1 unique quote, but likely more
      expect(uniqueQuotes.size).toBeGreaterThanOrEqual(1);
    });

    it('should return valid quote structure', async () => {
      const response = await agent
        .get('/api/quotes/random');

      expect(response.status).toBe(200);
      expect(Object.keys(response.body)).toEqual(['quote']);
      expect(response.body.quote).toBeTruthy();
      expect(response.body.quote.trim()).toBe(response.body.quote);
    });
  });

  describe('GET /api/quotes', () => {
    it('should return all quotes with count', async () => {
      const response = await agent
        .get('/api/quotes');

      expect(response.status).toBe(200);
      expect(response.body).toHaveProperty('quotes');
      expect(response.body).toHaveProperty('count');
      expect(Array.isArray(response.body.quotes)).toBe(true);
      expect(typeof response.body.count).toBe('number');
      expect(response.body.quotes.length).toBe(response.body.count);
      expect(response.body.count).toBeGreaterThan(0);
    });

    it('should return valid quote array', async () => {
      const response = await agent
        .get('/api/quotes');

      expect(response.status).toBe(200);
      
      // All quotes should be non-empty strings
      response.body.quotes.forEach(quote => {
        expect(typeof quote).toBe('string');
        expect(quote.length).toBeGreaterThan(0);
        expect(quote.trim()).toBe(quote);
      });
    });

    it('should return consistent data across requests', async () => {
      const response1 = await agent.get('/api/quotes');
      const response2 = await agent.get('/api/quotes');

      expect(response1.status).toBe(200);
      expect(response2.status).toBe(200);
      
      // The quotes array should be the same across requests
      expect(response1.body.quotes.length).toBe(response2.body.quotes.length);
      expect(response1.body.count).toBe(response2.body.count);
      
      // Verify the actual content is the same
      expect(response1.body.quotes).toEqual(response2.body.quotes);
    });

    it('should return expected quote count', async () => {
      const response = await agent
        .get('/api/quotes');

      expect(response.status).toBe(200);
      
      // Based on the configuration, we expect 20 quotes, but allow for fallback quotes
      expect(response.body.count).toBeGreaterThanOrEqual(5);
      expect(response.body.quotes.length).toBe(response.body.count);
    });

    it('should contain productivity-focused quotes', async () => {
      const response = await agent
        .get('/api/quotes');

      expect(response.status).toBe(200);
      
      // Look for some productivity-related keywords in the quotes
      const allQuotesText = response.body.quotes.join(' ').toLowerCase();
      
      // These are common themes in productivity quotes
      const productivityKeywords = [
        'progress', 'task', 'goal', 'focus', 'accomplish', 
        'success', 'work', 'effort', 'achieve', 'time'
      ];
      
      // At least some quotes should contain productivity-related terms
      const hasProductivityContent = productivityKeywords.some(keyword => 
        allQuotesText.includes(keyword)
      );
      
      expect(hasProductivityContent).toBe(true);
    });
  });

  describe('Quote randomness and consistency', () => {
    it('should have random quotes that are part of the full quote set', async () => {
      // Get all quotes first
      const allQuotesResponse = await agent.get('/api/quotes');
      const allQuotes = allQuotesResponse.body.quotes;

      // Get several random quotes
      const randomQuoteResponses = await Promise.all([
        agent.get('/api/quotes/random'),
        agent.get('/api/quotes/random'),
        agent.get('/api/quotes/random')
      ]);

      // Each random quote should be from the full set
      randomQuoteResponses.forEach(response => {
        expect(response.status).toBe(200);
        expect(allQuotes).toContain(response.body.quote);
      });
    });
  });
});