/**
 * Integration Tests for Admin Routes
 *
 * Tests admin authentication, user management, job management, transactions, analytics, and settings
 */

// Mock queue BEFORE any imports to prevent Redis connection
jest.mock('../../../queue', () => ({
  translationQueue: {
    add: jest.fn<() => Promise<{ id: string }>>().mockResolvedValue({ id: 'mock-job-id' }),
    process: jest.fn(),
    on: jest.fn(),
    close: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
    getJob: jest.fn<() => Promise<null>>().mockResolvedValue(null),
    getJobs: jest.fn<() => Promise<unknown[]>>().mockResolvedValue([]),
    pause: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
    resume: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
    clean: jest.fn<() => Promise<unknown[]>>().mockResolvedValue([]),
    empty: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
  },
}));

jest.mock('../../../config', () => {
  const actualConfig = jest.requireActual<typeof import('../../../config')>('../../../config');

  return {
    ...actualConfig,
    refreshConfigFromDatabase: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
    publishConfigUpdate: jest.fn<() => Promise<void>>().mockResolvedValue(undefined),
  };
});

import { beforeAll, beforeEach, describe, expect, it, jest } from '@jest/globals';
import request from 'supertest';
import { createServer } from '../../../server';
import { prismaMock } from '../../setup';
import { hashPassword } from '../../../utils/encryption';
import jwt from 'jsonwebtoken';
import { config } from '../../../config';
import { Application } from 'express';

describe('Admin Routes', () => {
  let app: Application;
  let adminToken: string;

  beforeAll(() => {
    app = createServer();
  });

  beforeEach(() => {
    prismaMock.adminUser.update.mockResolvedValue(mockAdminUser as any);

    // Generate admin token for authenticated requests
    adminToken = jwt.sign(
      {
        adminId: 'admin_123',
        email: 'admin@example.com',
        role: 'admin',
        type: 'admin_access',
      },
      config.jwtAdminSecret,
      {
        expiresIn: '1h',
        issuer: 'translate.press.zone',
        audience: 'admin',
      }
    );
  });

  const mockAdminUser = {
    id: 'admin_123',
    email: 'admin@example.com',
    password_hash: '$2b$12$mockhashedpassword',
    role: 'admin',
    is_active: true,
    last_login_at: null,
    created_at: new Date('2024-01-01'),
    updated_at: new Date('2024-01-01'),
  };

  describe('Admin Authentication', () => {
    describe('POST /v1/admin/auth/login', () => {
      it('should successfully login with valid admin credentials', async () => {
        const credentials = {
          email: 'admin@example.com',
          password: 'AdminPassword123!',
        };

        const passwordHash = await hashPassword(credentials.password);

        prismaMock.adminUser.findUnique.mockResolvedValue({
          ...mockAdminUser,
          password_hash: passwordHash,
        } as any);

        prismaMock.adminUser.update.mockResolvedValue(mockAdminUser as any);

        const response = await request(app)
          .post('/v1/admin/auth/login')
          .send(credentials)
          .expect(200);

        expect(response.body.access_token).toBeDefined();
        expect(response.body.refresh_token).toBeDefined();
        expect(response.body.user).toMatchObject({
          id: 'admin_123',
          email: 'admin@example.com',
          role: 'admin',
        });
      });

      it('should reject login with invalid credentials', async () => {
        const credentials = {
          email: 'admin@example.com',
          password: 'WrongPassword',
        };

        const correctPasswordHash = await hashPassword('CorrectPassword123!');

        prismaMock.adminUser.findUnique.mockResolvedValue({
          ...mockAdminUser,
          password_hash: correctPasswordHash,
        } as any);

        const response = await request(app)
          .post('/v1/admin/auth/login')
          .send(credentials)
          .expect(401);

        expect(response.body.error.code).toBe('INVALID_CREDENTIALS');
      });

      it('should reject non-admin users from admin login', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(null);

        const response = await request(app)
          .post('/v1/admin/auth/login')
          .send({
            email: 'user@example.com',
            password: 'Password123!',
          })
          .expect(401);

        expect(response.body.error.code).toBe('INVALID_CREDENTIALS');
      });

      it('should return admin JWT token', async () => {
        const credentials = {
          email: 'admin@example.com',
          password: 'AdminPassword123!',
        };

        const passwordHash = await hashPassword(credentials.password);

        prismaMock.adminUser.findUnique.mockResolvedValue({
          ...mockAdminUser,
          password_hash: passwordHash,
        } as any);

        prismaMock.adminUser.update.mockResolvedValue(mockAdminUser as any);

        const response = await request(app)
          .post('/v1/admin/auth/login')
          .send(credentials)
          .expect(200);

        // Verify the token is valid
        const decoded = jwt.verify(response.body.access_token, config.jwtAdminSecret) as any;
        expect(decoded.adminId).toBe('admin_123');
        expect(decoded.type).toBe('admin_access');
      });
    });
  });

  describe('User Management', () => {
    describe('GET /v1/admin/users', () => {
      it('should list all users with pagination', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        const mockUsers = [
          {
            id: 'user_1',
            email: 'user1@example.com',
            email_verified: true,
            status: 'active',
            created_at: new Date('2024-01-01'),
            updated_at: new Date('2024-01-01'),
            subscriptions: [{
              plan_tier: 'professional',
              billing_cycle: 'monthly',
              status: 'active',
              current_period_end: new Date('2024-02-01'),
              cancel_at_period_end: false,
            }],
            _count: {
              api_keys: 2,
              translation_jobs: 10,
              payments: 1,
            },
          },
          {
            id: 'user_2',
            email: 'user2@example.com',
            email_verified: false,
            status: 'active',
            created_at: new Date('2024-01-05'),
            updated_at: new Date('2024-01-05'),
            subscriptions: [],
            _count: {
              api_keys: 0,
              translation_jobs: 0,
              payments: 0,
            },
          },
        ];

        prismaMock.user.findMany.mockResolvedValue(mockUsers as any);
        prismaMock.user.count.mockResolvedValue(2);

        const response = await request(app)
          .get('/v1/admin/users?page=1&limit=20')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(response.body.data).toHaveLength(2);
        expect(response.body.pagination).toMatchObject({
          page: 1,
          limit: 20,
          total: 2,
          totalPages: 1,
        });
      });

      it('should filter users by status', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);
        prismaMock.user.findMany.mockResolvedValue([]);
        prismaMock.user.count.mockResolvedValue(0);

        await request(app)
          .get('/v1/admin/users?status=suspended')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(prismaMock.user.findMany).toHaveBeenCalledWith(
          expect.objectContaining({
            where: expect.objectContaining({
              status: 'suspended',
            }),
          })
        );
      });

      it('should return 401 for non-admin access', async () => {
        const response = await request(app)
          .get('/v1/admin/users')
          .expect(401);

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

    describe('GET /v1/admin/users/:id', () => {
      it('should get specific user details', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        const mockUser = {
          id: 'user_123',
          email: 'user@example.com',
          email_verified: true,
          status: 'active',
          created_at: new Date('2024-01-01'),
          updated_at: new Date('2024-01-01'),
          subscriptions: [{
            id: 'sub_123',
            plan_tier: 'professional',
            billing_cycle: 'monthly',
            status: 'active',
            paypal_subscription_id: 'PAYPAL_123',
            current_period_start: new Date('2024-01-01'),
            current_period_end: new Date('2024-02-01'),
            cancel_at_period_end: false,
            created_at: new Date('2024-01-01'),
            updated_at: new Date('2024-01-01'),
          }],
          api_keys: [],
          translation_jobs: [],
          payments: [],
          credit_transactions: [],
        };

        prismaMock.user.findUnique.mockResolvedValue(mockUser as any);
        prismaMock.creditTransaction.findFirst.mockResolvedValue({
          balance_after: 50000,
        } as any);

        const response = await request(app)
          .get('/v1/admin/users/user_123')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(response.body).toMatchObject({
          id: 'user_123',
          email: 'user@example.com',
          status: 'active',
          creditBalance: 50000,
        });
      });
    });

    describe('PATCH /v1/admin/users/:id', () => {
      it('should update user status', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        prismaMock.user.findUnique.mockResolvedValue({
          id: 'user_123',
          email: 'user@example.com',
          status: 'active',
        } as any);

        prismaMock.user.update.mockResolvedValue({
          id: 'user_123',
          email: 'user@example.com',
          email_verified: true,
          status: 'suspended',
          subscriptions: [],
          updated_at: new Date(),
        } as any);

        prismaMock.auditLog.create.mockResolvedValue({} as any);

        const response = await request(app)
          .patch('/v1/admin/users/user_123')
          .set('Authorization', `Bearer ${adminToken}`)
          .send({ status: 'suspended' })
          .expect(200);

        expect(response.body.status).toBe('suspended');
      });
    });

    describe('POST /v1/admin/users/:id/suspend', () => {
      it('should suspend user account', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        prismaMock.user.findUnique.mockResolvedValue({
          id: 'user_123',
          status: 'active',
        } as any);

        prismaMock.user.update.mockResolvedValue({
          id: 'user_123',
          status: 'suspended',
        } as any);

        prismaMock.auditLog.create.mockResolvedValue({} as any);

        const response = await request(app)
          .post('/v1/admin/users/user_123/suspend')
          .set('Authorization', `Bearer ${adminToken}`)
          .send({ reason: 'Violation of terms' })
          .expect(200);

        expect(response.body.success).toBe(true);
        expect(response.body.message).toContain('suspended successfully');
      });
    });
  });

  describe('Job Management', () => {
    describe('GET /v1/admin/jobs', () => {
      it('should list all translation jobs', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        const mockJobs = [
          {
            id: 'job_1',
            user_id: 'user_1',
            client_job_id: null,
            status: 'completed',
            source_lang: 'en',
            target_lang: 'es',
            model: 'gemini-3-flash-preview',
            plugin: 'translate',
            characters_used: 400,
            input_tokens: 300,
            output_tokens: 200,
            tokens_used: 500,
            cost: 0.005,
            customer_cost: 0.01,
            callback_url: 'https://example.com/webhook',
            created_at: new Date('2024-01-15'),
            completed_at: new Date('2024-01-15'),
            user: { email: 'user1@example.com' },
            webhook_deliveries: [{ success: true }],
          },
        ];

        prismaMock.translationJob.findMany.mockResolvedValue(mockJobs as any);
        prismaMock.translationJob.count.mockResolvedValue(1);

        const response = await request(app)
          .get('/v1/admin/jobs?page=1&limit=50')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(response.body.data).toHaveLength(1);
        expect(response.body.data[0]).toMatchObject({
          id: 'job_1',
          status: 'completed',
          userEmail: 'user1@example.com',
        });
      });

      it('should filter jobs by status', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);
        prismaMock.translationJob.findMany.mockResolvedValue([]);
        prismaMock.translationJob.count.mockResolvedValue(0);

        await request(app)
          .get('/v1/admin/jobs?status=failed')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(prismaMock.translationJob.findMany).toHaveBeenCalledWith(
          expect.objectContaining({
            where: expect.objectContaining({
              status: 'failed',
            }),
          })
        );
      });

      it('should filter jobs by user', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);
        prismaMock.translationJob.findMany.mockResolvedValue([]);
        prismaMock.translationJob.count.mockResolvedValue(0);

        await request(app)
          .get('/v1/admin/jobs?userId=user_123')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(prismaMock.translationJob.findMany).toHaveBeenCalledWith(
          expect.objectContaining({
            where: expect.objectContaining({
              user_id: 'user_123',
            }),
          })
        );
      });

      it('should paginate correctly', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);
        prismaMock.translationJob.findMany.mockResolvedValue([]);
        prismaMock.translationJob.count.mockResolvedValue(100);

        const response = await request(app)
          .get('/v1/admin/jobs?page=2&limit=25')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(response.body.pagination).toMatchObject({
          page: 2,
          limit: 25,
          total: 100,
          totalPages: 4,
        });
      });
    });

    describe('GET /v1/admin/jobs/:id', () => {
      it('should get job details', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        const mockJob = {
          id: 'job_123',
          user_id: 'user_123',
          client_job_id: 'client_job_1',
          status: 'completed',
          source_lang: 'en',
          target_lang: 'es',
          model: 'gemini-3-flash-preview',
          tone: 'professional',
          content: 'This is a test content for translation.',
          translation: 'Este es un contenido de prueba para traducción.',
          tokens_used: 100,
          cost: 0.001,
          error_message: null,
          processing_time_ms: 1500,
          callback_url: 'https://example.com/webhook',
          created_at: new Date('2024-01-15'),
          updated_at: new Date('2024-01-15'),
          completed_at: new Date('2024-01-15'),
          user: { email: 'user@example.com' },
          webhook_deliveries: [],
        };

        prismaMock.translationJob.findUnique.mockResolvedValue(mockJob as any);

        const response = await request(app)
          .get('/v1/admin/jobs/job_123')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(response.body.jobId).toBe('job_123');
        expect(response.body.userEmail).toBe('user@example.com');
        expect(response.body.webhookDeliveries).toBeDefined();
      });
    });
  });

  describe('Transaction Management', () => {
    describe('GET /v1/admin/transactions', () => {
      it('should list all transactions with pagination', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        const mockTransactions = [
          {
            id: 'tx_1',
            user_id: 'user_1',
            type: 'deduction',
            amount: -500,
            balance_after: 49500,
            description: 'Translation job',
            created_at: new Date('2024-01-15'),
            user: { id: 'user_1', email: 'user1@example.com', status: 'active' },
            job: null,
            payment: null,
          },
        ];

        prismaMock.creditTransaction.findMany.mockResolvedValue(mockTransactions as any);
        prismaMock.creditTransaction.count.mockResolvedValue(1);

        const response = await request(app)
          .get('/v1/admin/transactions?page=1&limit=20')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(response.body.data).toHaveLength(1);
        expect(response.body.data[0]).toMatchObject({
          id: 'tx_1',
          type: 'deduction',
          amount: -500,
        });
      });

      it('should filter by user', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);
        prismaMock.creditTransaction.findMany.mockResolvedValue([]);
        prismaMock.creditTransaction.count.mockResolvedValue(0);

        await request(app)
          .get('/v1/admin/transactions?userId=user_123')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(prismaMock.creditTransaction.findMany).toHaveBeenCalledWith(
          expect.objectContaining({
            where: expect.objectContaining({
              user_id: 'user_123',
            }),
          })
        );
      });

      it('should filter by date range', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);
        prismaMock.creditTransaction.findMany.mockResolvedValue([]);
        prismaMock.creditTransaction.count.mockResolvedValue(0);

        await request(app)
          .get('/v1/admin/transactions?startDate=2024-01-01&endDate=2024-01-31')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(prismaMock.creditTransaction.findMany).toHaveBeenCalledWith(
          expect.objectContaining({
            where: expect.objectContaining({
              created_at: expect.objectContaining({
                gte: expect.any(Date),
                lte: expect.any(Date),
              }),
            }),
          })
        );
      });
    });

    describe('GET /v1/admin/transactions/:id', () => {
      it('should get transaction details with payment info', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        const mockTransaction = {
          id: 'tx_123',
          user_id: 'user_123',
          type: 'allocation',
          amount: 50000,
          balance_after: 50000,
          description: 'Monthly credit allocation',
          created_at: new Date('2024-01-01'),
          user: {
            id: 'user_123',
            email: 'user@example.com',
            status: 'active',
            subscriptions: [{
              plan_tier: 'professional',
              status: 'active',
            }],
          },
          job: null,
          payment: {
            id: 'pay_123',
            amount: 99.00,
            currency: 'USD',
            status: 'completed',
            type: 'subscription',
            paypal_payment_id: 'PAYPAL_123',
            created_at: new Date('2024-01-01'),
          },
        };

        prismaMock.creditTransaction.findUnique.mockResolvedValue(mockTransaction as any);

        const response = await request(app)
          .get('/v1/admin/transactions/tx_123')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(response.body.id).toBe('tx_123');
        expect(response.body.relatedPayment).toBeDefined();
        expect(response.body.relatedPayment.amount).toBe('99');
      });
    });
  });

  describe('Analytics', () => {
    describe('GET /v1/admin/analytics/dashboard', () => {
      it('should get dashboard metrics', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        // Mock all required counts and aggregations
        prismaMock.user.count.mockResolvedValue(100);
        prismaMock.subscription.count.mockResolvedValue(50);
        prismaMock.subscription.groupBy.mockResolvedValue([
          { plan_tier: 'starter', _count: { id: 20 } },
          { plan_tier: 'professional', _count: { id: 25 } },
          { plan_tier: 'enterprise', _count: { id: 5 } },
        ] as any);
        prismaMock.translationJob.count.mockResolvedValue(1000);
        prismaMock.translationJob.aggregate.mockResolvedValue({
          _avg: { processing_time_ms: 2000, tokens_used: 500 },
          _sum: { amount: null },
        } as any);
        prismaMock.payment.aggregate.mockResolvedValue({
          _sum: { amount: 5000 },
        } as any);

        const response = await request(app)
          .get('/v1/admin/analytics/dashboard')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(response.body.users).toBeDefined();
        expect(response.body.subscriptions).toBeDefined();
        expect(response.body.translations).toBeDefined();
        expect(response.body.revenue).toBeDefined();
      });
    });

    describe('GET /v1/admin/analytics/revenue', () => {
      it('should get revenue statistics', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        const mockPayments = [
          {
            created_at: new Date('2024-01-15'),
            amount: 99.00,
            subscription_id: 'sub_1',
          },
          {
            created_at: new Date('2024-01-20'),
            amount: 29.00,
            subscription_id: 'sub_2',
          },
        ];

        prismaMock.payment.findMany.mockResolvedValue(mockPayments as any);

        const response = await request(app)
          .get('/v1/admin/analytics/revenue?days=30')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

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

    describe('GET /v1/admin/analytics/usage', () => {
      it('should get usage stats', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        const mockJobs = [
          {
            created_at: new Date('2024-01-15'),
            tokens_used: 500,
            user_id: 'user_1',
            model: 'gemini-3-flash-preview',
          },
        ];

        prismaMock.translationJob.findMany.mockResolvedValue(mockJobs as any);

        const response = await request(app)
          .get('/v1/admin/analytics/usage?days=30')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

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

    describe('GET /v1/admin/analytics/jobs', () => {
      it('should aggregate job metrics by target language', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);
        prismaMock.translationJob.count.mockResolvedValue(100);
        prismaMock.translationJob.aggregate
          .mockResolvedValueOnce({ _avg: { processing_time_ms: 2000 } } as any)
          .mockResolvedValueOnce({ _avg: { tokens_used: 500 } } as any);
        prismaMock.translationJob.groupBy.mockResolvedValue([
          {
            target_lang: 'es',
            _count: { id: 100 },
          },
        ] as any);

        const response = await request(app)
          .get('/v1/admin/analytics/jobs?days=30')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(response.body).toMatchObject({
          totals: { total: 100, completed: 100 },
          averages: { processingTimeMs: 2000, tokensUsed: 500 },
          topLanguages: [{ language: 'es', count: 100 }],
        });
      });
    });
  });

  describe('Settings Management', () => {
    describe('GET /v1/admin/settings', () => {
      it('should get all settings', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        const mockSettings = [
          {
            id: 'setting_1',
            key: 'pricing_per_1k_characters',
            value: 0.01,
            description: 'Price per 1000 characters',
            updated_at: new Date('2024-01-01'),
            updated_by: 'admin_123',
            admin: { email: 'admin@example.com' },
          },
        ];

        prismaMock.systemSetting.findMany.mockResolvedValue(mockSettings as any);

        const response = await request(app)
          .get('/v1/admin/settings')
          .set('Authorization', `Bearer ${adminToken}`)
          .expect(200);

        expect(Array.isArray(response.body)).toBe(true);
        expect(response.body[0]).toMatchObject({
          key: 'pricing_per_1k_characters',
          value: 0.01,
        });
      });
    });

    describe('PATCH /v1/admin/settings', () => {
      it('should update setting value', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        prismaMock.systemSetting.upsert.mockResolvedValue({
          id: 'setting_1',
          key: 'pricing_per_1k_characters',
          value: 0.015,
          description: 'Price per 1000 characters',
          updated_at: new Date(),
          updated_by: 'admin_123',
        } as any);
        prismaMock.auditLog.create.mockResolvedValue({} as any);
        prismaMock.$transaction.mockImplementation(async (callback: any) => callback(prismaMock));

        const response = await request(app)
          .patch('/v1/admin/settings')
          .set('Authorization', `Bearer ${adminToken}`)
          .send({
            settings: [
              { key: 'pricing_per_1k_characters', value: 0.015 },
            ],
          })
          .expect(200);

        expect(response.body.success).toBe(true);
        expect(response.body.settings[0].value).toBe(0.015);
      });

      it('should validate setting types with Zod schemas', async () => {
        prismaMock.adminUser.findUnique.mockResolvedValue(mockAdminUser as any);

        const response = await request(app)
          .patch('/v1/admin/settings')
          .set('Authorization', `Bearer ${adminToken}`)
          .send({
            settings: [
              { key: 'pricing_per_1k_characters', value: 'invalid_number' },
            ],
          })
          .expect(400);

        expect(response.body.error).toBe(true);
        expect(response.body.code).toBe('VALIDATION_ERROR');
      });
    });
  });
});