import { validateEnvironment } from './environment';

describe('validateEnvironment', () => {
  const validEnvironment = (
    overrides: Record<string, unknown> = {},
  ): Record<string, unknown> => ({
    NODE_ENV: 'test',
    PORT: '3007',
    DATABASE_URL:
      'postgresql://velody:velody@localhost:5432/velody?schema=public',
    STORAGE_ROOT: '/tmp/velody',
    PUBLIC_BASE_URL: 'http://localhost:3007',
    DEVICE_BOOTSTRAP_SECRET: 'device-secret',
    ACCOUNT_ACCESS_TOKEN_SECRET: 'account-secret',
    ACCOUNT_ACCESS_TOKEN_TTL_SECONDS: '900',
    MAX_UPLOAD_SIZE_BYTES: '1024',
    PADDLE_ENVIRONMENT: 'sandbox',
    PADDLE_API_KEY: 'test-paddle-api-key',
    PADDLE_WEBHOOK_SECRET: 'test-paddle-webhook-secret',
    PADDLE_PRO_MONTHLY_PRICE_ID: 'test-monthly-price-id',
    PADDLE_PRO_YEARLY_PRICE_ID: 'test-yearly-price-id',
    ...overrides,
  });

  it('accepts a valid environment', () => {
    const result = validateEnvironment(validEnvironment());

    expect(result.PORT).toBe(3007);
    expect(result.ACCOUNT_ACCESS_TOKEN_TTL_SECONDS).toBe(900);
    expect(result.MAX_UPLOAD_SIZE_BYTES).toBe(1024);
  });

  it('throws for missing values', () => {
    expect(() =>
      validateEnvironment({
        NODE_ENV: 'test',
      }),
    ).toThrow(/Invalid environment configuration/);
  });

  it('rejects reuse of the device-token secret for account tokens', () => {
    expect(() =>
      validateEnvironment(
        validEnvironment({
          DEVICE_BOOTSTRAP_SECRET: 'shared-secret',
          ACCOUNT_ACCESS_TOKEN_SECRET: 'shared-secret',
        }),
      ),
    ).toThrow(/account and device token secrets must be different/);
  });

  it('accepts the Paddle sandbox environment', () => {
    const result = validateEnvironment(
      validEnvironment({ PADDLE_ENVIRONMENT: 'sandbox' }),
    );

    expect(result.PADDLE_ENVIRONMENT).toBe('sandbox');
  });

  it('accepts the Paddle production environment', () => {
    const result = validateEnvironment(
      validEnvironment({ PADDLE_ENVIRONMENT: 'production' }),
    );

    expect(result.PADDLE_ENVIRONMENT).toBe('production');
  });

  it('rejects an invalid Paddle environment', () => {
    expect(() =>
      validateEnvironment(
        validEnvironment({ PADDLE_ENVIRONMENT: 'development' }),
      ),
    ).toThrow(/Invalid environment configuration/);
  });

  it.each([
    'PADDLE_API_KEY',
    'PADDLE_WEBHOOK_SECRET',
    'PADDLE_PRO_MONTHLY_PRICE_ID',
    'PADDLE_PRO_YEARLY_PRICE_ID',
  ])('rejects a missing %s', (key) => {
    const environment = validEnvironment();
    delete environment[key];

    expect(() => validateEnvironment(environment)).toThrow(
      /Invalid environment configuration/,
    );
  });
});