> ## Documentation Index
> Fetch the complete documentation index at: https://docs.jelou.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Testes

> Utilitários de teste para Jelou Functions: mock de contexto, cron, eventos, requisições e clientes de mensagens/memória.

## Configuração

Importe os utilitários de teste de `@jelou/functions/testing`:

```typescript theme={null}
import {
  createMockContext,
  createMockCronContext,
  createMockEventContext,
  createMockRequest,
  createMockPlatformRequest,
  createMockJelouClient,
  createMockMemoryClient,
} from "@jelou/functions/testing";
```

## `createMockContext(overrides?)`

Cria um contexto com valores padrão sensatos para testes.

```typescript theme={null}
const ctx = createMockContext();

const ctx2 = createMockContext({
  company: { id: 42, name: "Loja ABC" },
  user: { id: 99, names: "Maria Garcia" },
  bot: { id: "bot-123", name: "Bot de Suporte", channel: "whatsapp" },
});
```

## `createMockCronContext(expression, overrides?, cronName?)`

Cria um contexto com `isCron: true` e `trigger.type: "cron"`.

```typescript theme={null}
const ctx = createMockCronContext("0 9 * * *");
// ctx.isCron === true
// ctx.trigger === { type: "cron", cron: "0 9 * * *" }

const ctx2 = createMockCronContext("0 9 * * *", {}, "lembrete-diario");
// ctx2.trigger.cronName === "lembrete-diario"
```

## `createMockEventContext(eventName, overrides?)`

Cria um contexto com `isEvent: true` e `trigger.type: "event"`.

```typescript theme={null}
const ctx = createMockEventContext("payment.completed");
// ctx.isEvent === true
```

## `createMockRequest(body?, options?)`

Cria um objeto Web `Request` padrão.

```typescript theme={null}
const req = createMockRequest();
// GET http://localhost:8000/

const req2 = createMockRequest({ telefone: "5511987654321" });
// POST com body JSON
```

## `createMockPlatformRequest(token, body?, options?)`

Cria um `Request` com header `X-Jelou-Token`. Útil para testar funções autenticadas com runtime tokens.

```typescript theme={null}
const req = createMockPlatformRequest("jfn_rt_test123");
// GET com X-Jelou-Token: jfn_rt_test123

const req2 = createMockPlatformRequest("jfn_rt_test123", { query: "test" });
// POST com body JSON + X-Jelou-Token
```

## `createMockJelouClient(options?)`

Cria um mock do cliente de mensagens com gravação de chamadas.

```typescript theme={null}
const mockJelou = createMockJelouClient();
const ctx = createMockContext({ jelou: mockJelou });

await ctx.jelou.send({ type: "text", to: "+5511987654321", text: "Olá" });

mockJelou.calls.length;          // 1
mockJelou.calls[0].method;       // "send"
mockJelou.calls[0].args.type;    // "text"
```

### Resultados personalizados

```typescript theme={null}
const mockJelou = createMockJelouClient({
  sendResult: { messageId: "msg-custom-123" },
  templateResult: [{ id: "tmpl-1", destination: "+5511987654321" }],
});
```

### Reset entre testes

```typescript theme={null}
mockJelou.reset();
```

## `createMockMemoryClient(options?)`

Cria um mock do cliente de memória com store in-memory.

```typescript theme={null}
const mockMemory = createMockMemoryClient({
  store: { passo: "inicio", tentativas: 0 },
});
const ctx = createMockContext({ memory: mockMemory });

const passo = await ctx.memory.get("passo", "desconhecido"); // "inicio"
await ctx.memory.set("passo", "confirmacao", 3600);
```

### Reset entre testes

```typescript theme={null}
mockMemory.reset();
```

## Exemplo completo

```typescript index.test.ts theme={null}
import { assertEquals } from "jsr:@std/assert";
import { define, z } from "@jelou/functions";
import {
  createMockContext,
  createMockCronContext,
  createMockRequest,
  createMockPlatformRequest,
  createMockJelouClient,
} from "@jelou/functions/testing";

const fn = define({
  name: "consultar-cliente",
  description: "Busca informações do cliente por telefone",
  input: z.object({ telefone: z.string().min(10) }),
  handler: async (input, ctx) => ({
    nome: "Maria Garcia",
    plano: "Premium",
    companyId: ctx.company.id,
  }),
});

Deno.test("retorna info do cliente com company ID correto", async () => {
  const ctx = createMockContext({ company: { id: 42, name: "Loja ABC" } });
  const req = createMockRequest({ telefone: "5511987654321" });
  const result = await fn.handler({ telefone: "5511987654321" }, ctx, req);
  assertEquals(result.companyId, 42);
});

Deno.test("mock de mensagens grava chamadas", async () => {
  const mockJelou = createMockJelouClient();
  const ctx = createMockContext({ jelou: mockJelou });
  await ctx.jelou.send({ type: "text", to: "+5511987654321", text: "Olá" });
  assertEquals(mockJelou.calls.length, 1);
  assertEquals(mockJelou.calls[0].args.type, "text");
});

Deno.test("platform request inclui header de token", () => {
  const req = createMockPlatformRequest("jfn_rt_test123", { action: "test" });
  assertEquals(req.headers.get("x-jelou-token"), "jfn_rt_test123");
});
```

## `createMockApp(tools, config?)`

Cria um `EdgeApp` mock para testes de funções multi-tool.

```typescript theme={null}
import { createMockApp, createMockContext, createMockRequest } from "@jelou/functions/testing";
import { define, z } from "@jelou/functions";

const myApp = createMockApp({
  enviarEmail: define({
    description: "Envia um e-mail",
    input: z.object({ to: z.string() }),
    handler: async () => ({ sent: true }),
  }),
});

Deno.test("app tem os tools corretos", () => {
  assertEquals(Object.keys(myApp.tools), ["enviarEmail"]);
});
```

<Tip>
  Execute os testes com Deno:

  ```bash theme={null}
  deno test
  ```
</Tip>