@hed-hog/core 0.0.387 → 0.0.390

package/src/integration-profile/testers/remaining.testers.spec.ts

@@ -0,0 +1,401 @@
+import { afterEach, beforeEach, describe, expect, it, jest } from '@jest/globals';
+import { AI_TESTERS } from './ai.testers';
+import { EMAIL_TESTERS } from './email.testers';
+import { INFRASTRUCTURE_TESTERS } from './infrastructure.testers';
+import { MESSAGING_TESTERS } from './messaging.testers';
+import { PAYMENT_TESTERS } from './payment.testers';
+import { IntegrationTestContext, IntegrationTester } from './integration-tester.types';
+
+/**
+ * Cobre os testers que falam HTTP direto. O foco é a tradução de resposta em
+ * veredito — que é onde mora a diferença entre "sua chave está errada" e uma
+ * mensagem crua de API que não ajuda ninguém.
+ */
+
+const all = [
+  ...EMAIL_TESTERS,
+  ...MESSAGING_TESTERS,
+  ...AI_TESTERS,
+  ...PAYMENT_TESTERS,
+  ...INFRASTRUCTURE_TESTERS,
+];
+
+const bySlug = (slug: string): IntegrationTester =>
+  all.find((tester) => tester.providerSlug === slug)!;
+
+const ctx = (): IntegrationTestContext => ({
+  signal: AbortSignal.timeout(5_000),
+  typeSlug: 'test',
+  providerSlug: 'test',
+  secretValues: [],
+});
+
+function jsonResponse(body: unknown, status = 200) {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    text: async () => JSON.stringify(body),
+  } as unknown as Response;
+}
+
+let fetchMock: jest.Mock;
+
+beforeEach(() => {
+  fetchMock = jest.fn();
+  global.fetch = fetchMock as unknown as typeof fetch;
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe('gmail tester', () => {
+  const tester = bySlug('gmail');
+  const config = {
+    client_id: 'id',
+    client_secret: 'secret',
+    refresh_token: 'refresh',
+    from_email: 'envio@acme.com',
+  };
+
+  it('aprova quando a troca do refresh token funciona', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ access_token: 'token' }));
+
+    await expect(tester.test(config, ctx())).resolves.toMatchObject({ ok: true });
+  });
+
+  it('separa credencial de app errada de autorização revogada', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ error: 'invalid_client' }, 401));
+    await expect(tester.test(config, ctx())).resolves.toEqual({
+      ok: false,
+      error: 'Invalid Client ID or Client secret.',
+    });
+
+    fetchMock.mockResolvedValueOnce(jsonResponse({ error: 'invalid_grant' }, 400));
+    const revoked = await tester.test(config, ctx());
+    expect(revoked.ok).toBe(false);
+    expect(revoked.error).toContain('revoked');
+  });
+
+  it('exige o remetente, mantendo a regra que a tela de e-mail já dependia', async () => {
+    const outcome = await tester.test({ ...config, from_email: '' }, ctx());
+
+    expect(outcome).toEqual({ ok: false, error: 'Sender email is required.' });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});
+
+describe('resend tester', () => {
+  const tester = bySlug('resend');
+  const config = { api_token: 'token', domain: 'acme.com' };
+
+  it('aprova quando o domínio está verificado na conta', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse({ data: [{ name: 'acme.com', status: 'verified' }] }),
+    );
+
+    const outcome = await tester.test(config, ctx());
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome.warning).toBeUndefined();
+  });
+
+  it('avisa (sem reprovar) quando o domínio não está verificado', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse({ data: [{ name: 'acme.com', status: 'pending' }] }),
+    );
+
+    const outcome = await tester.test(config, ctx());
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome.warning).toContain('not verified');
+  });
+
+  it('avisa quando o domínio nem existe na conta', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ data: [{ name: 'outra.com' }] }));
+
+    const outcome = await tester.test(config, ctx());
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome.warning).toContain('not registered');
+  });
+
+  it('reprova o token inválido', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ message: 'unauthorized' }, 401));
+
+    await expect(tester.test(config, ctx())).resolves.toEqual({
+      ok: false,
+      error: 'Invalid Resend API token.',
+    });
+  });
+});
+
+describe('evolution-api tester', () => {
+  const tester = bySlug('evolution-api');
+  const config = {
+    host: 'https://evolution.acme.com',
+    token: 'apikey',
+    instance_name: 'vendas',
+  };
+
+  it('usa o header apikey e o endpoint de estado da instância', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ instance: { state: 'open' } }));
+
+    const outcome = await tester.test(config, ctx());
+
+    expect(outcome.ok).toBe(true);
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe('https://evolution.acme.com/instance/connectionState/vendas');
+    expect((init.headers as Record<string, string>).apikey).toBe('apikey');
+  });
+
+  it('aprova com aviso quando a instância existe mas está desconectada', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ instance: { state: 'close' } }));
+
+    const outcome = await tester.test(config, ctx());
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome.warning).toContain('QR code');
+  });
+
+  it('distingue token inválido de instância inexistente', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({}, 401));
+    await expect(tester.test(config, ctx())).resolves.toMatchObject({
+      error: 'Invalid Evolution API token.',
+    });
+
+    fetchMock.mockResolvedValueOnce(jsonResponse({}, 404));
+    const notFound = await tester.test(config, ctx());
+    expect(notFound.error).toContain('"vendas" was not found');
+  });
+
+  it('rejeita um host que não é http/https', async () => {
+    await expect(
+      tester.test({ ...config, host: 'ftp://evolution.acme.com' }, ctx()),
+    ).rejects.toThrow('Evolution API host must use http or https.');
+  });
+});
+
+describe('whatsapp-official tester', () => {
+  const tester = bySlug('whatsapp-official');
+  const config = {
+    app_id: 'app',
+    app_secret: 'secret',
+    waba_id: '123',
+    access_token: 'token',
+    verify_token: 'verify',
+  };
+
+  it('lê o WABA na Graph API e devolve o nome da conta', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ id: '123', name: 'Acme Ltda' }));
+
+    await expect(tester.test(config, ctx())).resolves.toEqual({
+      ok: true,
+      info: 'Acme Ltda',
+    });
+  });
+
+  it('exige os campos que o webhook precisa, antes de ir à rede', async () => {
+    const outcome = await tester.test({ ...config, app_secret: '' }, ctx());
+
+    expect(outcome.ok).toBe(false);
+    expect(outcome.error).toContain('App Secret');
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('propaga a mensagem de erro da Meta', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse({ error: { message: 'Invalid OAuth access token.' } }, 400),
+    );
+
+    const outcome = await tester.test(config, ctx());
+
+    expect(outcome.ok).toBe(false);
+    expect(outcome.error).toContain('Invalid OAuth access token.');
+  });
+});
+
+describe('openai tester', () => {
+  const tester = bySlug('openai');
+
+  it('avisa quando o modelo configurado não está disponível para a conta', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ data: [{ id: 'gpt-4o' }] }));
+
+    const outcome = await tester.test(
+      { api_key: 'sk-test', model: 'modelo-inexistente' },
+      ctx(),
+    );
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome.warning).toContain('modelo-inexistente');
+  });
+
+  it('envia a organização quando ela está configurada', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ data: [] }));
+
+    await tester.test({ api_key: 'sk-test', organization: 'org-1' }, ctx());
+
+    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect((init.headers as Record<string, string>)['OpenAI-Organization']).toBe(
+      'org-1',
+    );
+  });
+
+  it('reprova a chave inválida', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({}, 401));
+
+    await expect(tester.test({ api_key: 'sk-bad' }, ctx())).resolves.toEqual({
+      ok: false,
+      error: 'Invalid OpenAI API key.',
+    });
+  });
+});
+
+describe('claude tester', () => {
+  const tester = bySlug('claude');
+
+  it('usa os headers da API da Anthropic', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ data: [{ id: 'claude-opus' }] }));
+
+    await tester.test({ api_key: 'sk-ant' }, ctx());
+
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe('https://api.anthropic.com/v1/models');
+    const headers = init.headers as Record<string, string>;
+    expect(headers['x-api-key']).toBe('sk-ant');
+    expect(headers['anthropic-version']).toBe('2023-06-01');
+  });
+});
+
+describe('stripe tester', () => {
+  const tester = bySlug('stripe');
+
+  it('autentica com Basic e a chave como usuário', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ livemode: true }));
+
+    await tester.test({ secret_key: 'sk_live_x', mode: 'production' }, ctx());
+
+    const [, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    const auth = (init.headers as Record<string, string>).Authorization;
+    expect(Buffer.from(auth.replace('Basic ', ''), 'base64').toString()).toBe(
+      'sk_live_x:',
+    );
+  });
+
+  it('avisa quando o modo do perfil não bate com o modo da chave', async () => {
+    fetchMock.mockResolvedValueOnce(jsonResponse({ livemode: false }));
+    const testKeyInProduction = await tester.test(
+      { secret_key: 'sk_test_x', mode: 'production' },
+      ctx(),
+    );
+    expect(testKeyInProduction.ok).toBe(true);
+    expect(testKeyInProduction.warning).toContain('test key');
+
+    fetchMock.mockResolvedValueOnce(jsonResponse({ livemode: true }));
+    const liveKeyInSandbox = await tester.test(
+      { secret_key: 'sk_live_x', mode: 'sandbox' },
+      ctx(),
+    );
+    expect(liveKeyInSandbox.warning).toContain('live key');
+  });
+
+  it('não avisa quando modo e chave combinam', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({ livemode: true }));
+
+    const outcome = await tester.test(
+      { secret_key: 'sk_live_x', mode: 'production' },
+      ctx(),
+    );
+
+    expect(outcome.warning).toBeUndefined();
+  });
+});
+
+describe('mercado_pago tester', () => {
+  const tester = bySlug('mercado_pago');
+
+  it('identifica a conta pelo apelido e site', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse({ nickname: 'ACME', site_id: 'MLB' }),
+    );
+
+    await expect(tester.test({ access_token: 'APP_USR-x' }, ctx())).resolves.toEqual(
+      { ok: true, info: 'ACME — MLB' },
+    );
+  });
+});
+
+describe('google_play tester', () => {
+  const tester = bySlug('google_play');
+
+  it('reprova um service account JSON malformado, sem ir à rede', async () => {
+    const outcome = await tester.test(
+      { package_name: 'com.acme.app', service_account_json: '{ quebrado' },
+      ctx(),
+    );
+
+    expect(outcome).toEqual({
+      ok: false,
+      error: 'The service account JSON is not valid JSON.',
+    });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+
+  it('exige alguma credencial além do package name', async () => {
+    const outcome = await tester.test({ package_name: 'com.acme.app' }, ctx());
+
+    expect(outcome.ok).toBe(false);
+    expect(outcome.error).toContain('client email and private key');
+  });
+});
+
+describe('digitalocean tester', () => {
+  const tester = bySlug('digitalocean');
+  const config = { api_token: 'dop_v1', cluster_id: 'abc', region: 'nyc1' };
+
+  it('identifica o cluster', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse({
+        kubernetes_cluster: { name: 'hub', region: 'nyc3', node_pools: [] },
+      }),
+    );
+
+    await expect(tester.test(config, ctx())).resolves.toEqual({
+      ok: true,
+      info: 'hub (nyc3)',
+    });
+  });
+
+  it('avisa quando o node pool de vídeo sumiu do cluster', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse({
+        kubernetes_cluster: {
+          name: 'hub',
+          region: 'nyc3',
+          node_pools: [{ name: 'default' }],
+        },
+      }),
+    );
+
+    const outcome = await tester.test(
+      { ...config, video_node_pool_name: 'video' },
+      ctx(),
+    );
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome.warning).toContain('"video" no longer exists');
+  });
+
+  it.each([
+    [401, 'Invalid DigitalOcean API token.'],
+    [403, 'This token has no permission to read Kubernetes clusters.'],
+    [404, 'Cluster "abc" was not found in this account.'],
+  ])('traduz o HTTP %s', async (status, expected) => {
+    fetchMock.mockResolvedValue(jsonResponse({}, status));
+
+    await expect(tester.test(config, ctx())).resolves.toEqual({
+      ok: false,
+      error: expected,
+    });
+  });
+});

package/src/integration-profile/testers/storage.testers.spec.ts

@@ -0,0 +1,185 @@
+import { afterEach, beforeEach, describe, expect, it, jest } from '@jest/globals';
+
+const send = jest.fn<any>();
+const destroy = jest.fn();
+
+jest.mock('@aws-sdk/client-s3', () => ({
+  S3Client: jest.fn().mockImplementation((config: unknown) => ({
+    config,
+    send,
+    destroy,
+  })),
+  HeadBucketCommand: jest.fn().mockImplementation((input: unknown) => ({ input })),
+}));
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { S3Client } = require('@aws-sdk/client-s3');
+import { STORAGE_TESTERS } from './storage.testers';
+import { IntegrationTestContext, IntegrationTester } from './integration-tester.types';
+
+const bySlug = (slug: string): IntegrationTester =>
+  STORAGE_TESTERS.find((tester) => tester.providerSlug === slug)!;
+
+const ctx = (): IntegrationTestContext => ({
+  signal: AbortSignal.timeout(5_000),
+  typeSlug: 'storage',
+  providerSlug: 'test',
+  secretValues: [],
+});
+
+const s3Config = {
+  access_key_id: 'AKIA...',
+  secret_access_key: 'secret',
+  bucket: 'meu-bucket',
+  region: 'sa-east-1',
+};
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+afterEach(() => {
+  jest.restoreAllMocks();
+});
+
+describe('s3 tester', () => {
+  const tester = bySlug('s3');
+
+  it('aprova quando o HeadBucket responde, informando bucket e região', async () => {
+    send.mockResolvedValue({});
+
+    const outcome = await tester.test(s3Config, ctx());
+
+    expect(outcome).toEqual({ ok: true, info: 'meu-bucket (sa-east-1)' });
+    expect(S3Client).toHaveBeenCalledWith(
+      expect.objectContaining({ region: 'sa-east-1' }),
+    );
+    // O cliente é sempre destruído, mesmo no caminho feliz.
+    expect(destroy).toHaveBeenCalled();
+  });
+
+  it.each([
+    [{ name: 'InvalidAccessKeyId' }, 'Invalid access key ID.'],
+    [{ name: 'SignatureDoesNotMatch' }, 'Invalid secret access key.'],
+    [{ name: 'NotFound' }, 'Bucket "meu-bucket" was not found.'],
+    [
+      { name: 'Forbidden' },
+      'These credentials have no permission to access the bucket "meu-bucket".',
+    ],
+    [
+      { name: 'PermanentRedirect' },
+      'Bucket "meu-bucket" lives in another region.',
+    ],
+  ])('traduz o erro %o do SDK', async (error, expected) => {
+    send.mockRejectedValue(Object.assign(new Error('raw sdk noise'), error));
+
+    await expect(tester.test(s3Config, ctx())).resolves.toEqual({
+      ok: false,
+      error: expected,
+    });
+  });
+
+  it('usa o status HTTP quando o SDK não nomeia o erro', async () => {
+    send.mockRejectedValue(
+      Object.assign(new Error('boom'), { $metadata: { httpStatusCode: 404 } }),
+    );
+
+    await expect(tester.test(s3Config, ctx())).resolves.toMatchObject({
+      ok: false,
+      error: 'Bucket "meu-bucket" was not found.',
+    });
+  });
+
+  it('não vai à rede quando falta credencial', async () => {
+    const outcome = await tester.test({ bucket: 'b' }, ctx());
+
+    expect(outcome.ok).toBe(false);
+    expect(send).not.toHaveBeenCalled();
+  });
+
+  it('inclui o session_token quando o perfil usa credenciais temporárias (STS)', async () => {
+    send.mockResolvedValue({});
+
+    await tester.test({ ...s3Config, session_token: 'temporario' }, ctx());
+
+    expect(S3Client).toHaveBeenCalledWith(
+      expect.objectContaining({
+        credentials: expect.objectContaining({ sessionToken: 'temporario' }),
+      }),
+    );
+  });
+});
+
+describe('s3-compatible tester', () => {
+  const tester = bySlug('s3-compatible');
+
+  it('aponta para o endpoint informado usando path-style', async () => {
+    send.mockResolvedValue({});
+
+    const outcome = await tester.test(
+      { ...s3Config, endpoint: 'https://minio.acme.com' },
+      ctx(),
+    );
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome.info).toContain('minio.acme.com');
+    expect(S3Client).toHaveBeenCalledWith(
+      expect.objectContaining({
+        endpoint: 'https://minio.acme.com',
+        forcePathStyle: true,
+      }),
+    );
+  });
+
+  it('rejeita um endpoint que não é http/https', async () => {
+    await expect(
+      tester.test({ ...s3Config, endpoint: 'file:///tmp' }, ctx()),
+    ).rejects.toThrow('Endpoint must use http or https.');
+  });
+});
+
+describe('local tester', () => {
+  const tester = bySlug('local');
+
+  it('aprova um diretório existente e gravável', async () => {
+    const outcome = await tester.test({ base_path: process.cwd() }, ctx());
+
+    expect(outcome).toEqual({ ok: true, info: process.cwd() });
+  });
+
+  it('reprova um diretório inexistente com uma mensagem acionável', async () => {
+    const outcome = await tester.test(
+      { base_path: '/caminho/que/nao/existe/hedhog' },
+      ctx(),
+    );
+
+    expect(outcome.ok).toBe(false);
+    expect(outcome.error).toContain('does not exist');
+  });
+});
+
+describe('gcs tester', () => {
+  const tester = bySlug('gcs');
+
+  it('reprova um keyfile que não é JSON válido, sem ir à rede', async () => {
+    const outcome = await tester.test(
+      { key_file_json: '{ isso não é json', bucket: 'b' },
+      ctx(),
+    );
+
+    expect(outcome).toEqual({
+      ok: false,
+      error: 'The service account JSON is not valid JSON.',
+    });
+  });
+
+  it('reprova um keyfile sem client_email', async () => {
+    const outcome = await tester.test(
+      { key_file_json: JSON.stringify({ project_id: 'p' }), bucket: 'b' },
+      ctx(),
+    );
+
+    expect(outcome.ok).toBe(false);
+    expect(outcome.error).toContain('client_email');
+  });
+});