@vibe2founder/tests2dialects 0.1.0 → 0.2.0

package/dist/examples/imperative.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/imperative.spec.js

@@ -0,0 +1,46 @@
+import { ImperativeDialect } from "../src/index.js";
+const { ensure, check, that, stub, initAll } = ImperativeDialect;
+ensure("Sistema de Segurança e Compliance", () => {
+    // Stubs de Infraestrutura
+    const firewall = stub();
+    const logger = stub();
+    initAll(() => {
+        // Configuração Hardened
+        firewall.forceReturn({ allowed: true, threatLevel: 0 });
+    });
+    check("Deve bloquear conexões de IPs na blacklist", () => {
+        const maliciousIp = "192.168.1.666";
+        // Reconfigurando stub para este caso
+        firewall.executes((ip) => {
+            return ip === maliciousIp ? { allowed: false } : { allowed: true };
+        });
+        const access = firewall(maliciousIp);
+        that(access.allowed).is(false);
+        that(firewall).triggered();
+        that(firewall).calledWith(maliciousIp);
+    });
+    check("Deve registrar auditoria para cada acesso", () => {
+        logger("Acesso admin iniciado");
+        that(logger).triggeredCount(1);
+        that(logger).calledWith("Acesso admin iniciado");
+    });
+});
+ensure("Validação Estrutural da API V2", () => {
+    const apiResponse = {
+        status: 200,
+        data: {
+            id: "uuid-1234",
+            role: "admin",
+            meta: { version: 2 },
+        },
+    };
+    check("Payload deve conter metadados corretos", () => {
+        that(apiResponse.status).is(200);
+        that(apiResponse.data.role).is("admin");
+        that(apiResponse.data.meta.version).is(2);
+    });
+    check("Campos obrigatórios devem existir", () => {
+        that(apiResponse.data).isOk();
+        that(apiResponse.data.id).matches(/^uuid-/);
+    });
+});

package/dist/examples/math.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/math.spec.js

@@ -0,0 +1,39 @@
+import { MathDialect } from "../src/index.js";
+const { axiom, proof, implies, arbitrary } = MathDialect;
+// --- Domain Logic: Financial Calculation ---
+const calculateInterests = (principal, rate, time) => {
+    return principal * Math.pow(1 + rate, time);
+};
+axiom("Teoria Financeira: Juros Compostos", () => {
+    proof("O capital deve crescer exponencialmente", () => {
+        const principal = 1000;
+        const rate = 0.05; // 5%
+        const time = 2; // anos
+        const result = calculateInterests(principal, rate, time);
+        // 1000 * (1.05)^2 = 1000 * 1.1025 = 1102.5
+        implies(result).is(1102.5);
+    });
+    proof("Taxa zero implica em imutabilidade do capital", () => {
+        const principal = 500;
+        const result = calculateInterests(principal, 0, 10);
+        implies(result).is(principal);
+    });
+});
+axiom("Álgebra Booleana: Leis de De Morgan", () => {
+    const A = true;
+    const B = false;
+    proof("A negação da disjunção é a conjunção das negações", () => {
+        const lhs = !(A || B);
+        const rhs = !A && !B;
+        implies(lhs).is(rhs);
+    });
+});
+axiom("Análise de Funções Recursivas", () => {
+    const factorial = arbitrary();
+    // Configurando comportamento axiomático
+    factorial.derive((n) => (n <= 1 ? 1 : n * factorial(n - 1)));
+    proof("Fatorial de 5 converge para 120", () => {
+        const res = factorial(5);
+        implies(res).is(120);
+    });
+});

package/dist/examples/narrative.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/narrative.spec.js

@@ -0,0 +1,47 @@
+import { NarrativeDialect } from "../src/index.js";
+const { intend, detail, to, standIn, background, before } = NarrativeDialect;
+intend("Jornada de Compra do Usuário", () => {
+    // Atores (Mocks)
+    const cart = standIn();
+    const paymentGateway = standIn();
+    const notificationService = standIn();
+    before(() => {
+        // Limpa estado para cada cena
+        cart.clear();
+        paymentGateway.clear();
+        notificationService.clear();
+    });
+    background(() => {
+        // Contexto: Carrinho tem itens e gateway está online
+        cart.getTotal.respondsWith(150.0); // Especifica o método
+        paymentGateway.process.respondsWith(true); // Especifica o método
+    });
+    detail("O cliente finaliza a compra com sucesso", () => {
+        // Ação: Usuário clica em 'Checkout'
+        const total = cart.getTotal();
+        const success = paymentGateway.process(total);
+        if (success) {
+            notificationService.sendEmail("Compra aprovada!");
+        }
+        // Expectativas narrativas
+        to(cart).wasCalled();
+        to(paymentGateway).uploaded(total); // Alias mental para 'received'
+        to(notificationService).received("Compra aprovada!");
+    });
+    detail("O sistema deve lidar com falha no pagamento", () => {
+        // Mudança de enredo: Gateway recusa
+        paymentGateway.process.respondsWith(false);
+        const success = paymentGateway.process(100);
+        to(success).be(false);
+        to(notificationService).not.wasCalled();
+    });
+});
+intend("Onboarding de Novos Membros", () => {
+    const database = standIn();
+    detail("Deve criar perfil padrão ao registrar", () => {
+        const newUser = { name: "Alice", email: "alice@wonder.land" };
+        // Simula o registro
+        database.save(newUser);
+        to(database).received(newUser);
+    });
+});

package/dist/examples/polyglot-shopping-cart.spec.d.ts

@@ -0,0 +1,11 @@
+/**
+ * 🛒 Shopping Cart - Exemplo Poliglota
+ *
+ * Este arquivo demonstra como usar os 3 dialetos de forma semântica e coerente
+ * para testar diferentes camadas de uma mesma funcionalidade: um carrinho de compras.
+ *
+ * - 📐 Matemático: Testa a lógica PURA de cálculo (descontos, totais)
+ * - 📖 Narrativo: Testa a JORNADA do usuário (adicionar, remover, finalizar)
+ * - 🛡️ Imperativo: Testa a INTEGRAÇÃO com API (gateway de pagamento)
+ */
+export {};

package/dist/examples/polyglot-shopping-cart.spec.js

@@ -0,0 +1,161 @@
+/**
+ * 🛒 Shopping Cart - Exemplo Poliglota
+ *
+ * Este arquivo demonstra como usar os 3 dialetos de forma semântica e coerente
+ * para testar diferentes camadas de uma mesma funcionalidade: um carrinho de compras.
+ *
+ * - 📐 Matemático: Testa a lógica PURA de cálculo (descontos, totais)
+ * - 📖 Narrativo: Testa a JORNADA do usuário (adicionar, remover, finalizar)
+ * - 🛡️ Imperativo: Testa a INTEGRAÇÃO com API (gateway de pagamento)
+ */
+import { 
+// 📐 Matemático - para lógica pura
+axiom, proof, implies, given, 
+// 📖 Narrativo - para jornada do usuário
+intend, scenario, to, standIn, background, 
+// 🛡️ Imperativo - para integração de sistema
+ensure, check, that, stub, initAll, reset, } from "../src/index.js";
+// =============================================================================
+// 📐 CAMADA MATEMÁTICA: Lógica Pura de Preços
+// =============================================================================
+// Aqui provamos verdades universais sobre cálculos financeiros.
+// Não há dependências externas, não há estado. Apenas matemática.
+axiom("Teoria de Cálculo de Preços", () => {
+    let calcDiscount;
+    let calcTotal;
+    let applyTax;
+    given(() => {
+        // Funções puras - determinísticas, sem side effects
+        calcDiscount = (price, percent) => price - price * (percent / 100);
+        calcTotal = (items) => items.reduce((sum, i) => sum + i.price * i.qty, 0);
+        applyTax = (subtotal, rate) => Math.round(subtotal * (1 + rate) * 100) / 100;
+    });
+    proof("Desconto de 10% em R$100 implica R$90", () => {
+        implies(calcDiscount(100, 10)).is(90);
+    });
+    proof("Desconto de 0% preserva o valor original", () => {
+        implies(calcDiscount(250, 0)).is(250);
+    });
+    proof("Desconto de 100% anula o preço", () => {
+        implies(calcDiscount(500, 100)).is(0);
+    });
+    proof("Total de carrinho vazio converge para zero", () => {
+        implies(calcTotal([])).is(0);
+    });
+    proof("Total de 3 itens a R$10 cada (qty=2) implica R$60", () => {
+        const items = [
+            { price: 10, qty: 2 },
+            { price: 10, qty: 2 },
+            { price: 10, qty: 2 },
+        ];
+        implies(calcTotal(items)).is(60);
+    });
+    proof("Imposto de 10% sobre R$100 resulta em R$110", () => {
+        implies(applyTax(100, 0.1)).is(110);
+    });
+});
+// =============================================================================
+// 📖 CAMADA NARRATIVA: Jornada do Usuário
+// =============================================================================
+// Aqui contamos histórias que o PM pode ler e entender.
+// Descrevemos a experiência do usuário em linguagem natural.
+intend("Jornada de Compra do Usuário", () => {
+    const cart = standIn(); // Dublê do serviço de carrinho
+    const user = standIn(); // Dublê do usuário
+    background(() => {
+        // Preparação do cenário
+        cart.respondsWith({ items: [], total: 0 });
+        user.respondsWith({ name: "João", loggedIn: true });
+    });
+    scenario("Usuário adiciona primeiro produto ao carrinho", () => {
+        cart.add({ name: "Camiseta", price: 49.9 });
+        cart.respondsWith({
+            items: [{ name: "Camiseta", price: 49.9 }],
+            total: 49.9,
+        });
+        to(cart).wasCalled();
+        to(cart.items).have("length");
+    });
+    scenario("Usuário aplica cupom de desconto", () => {
+        const coupon = standIn();
+        coupon.respondsWith({ valid: true, discount: 15 });
+        // Link the mock logic for the purpose of this example
+        cart.applyCoupon.actsLike(() => coupon("DESCONTO15"));
+        cart.applyCoupon("DESCONTO15");
+        cart.respondsWith({ total: 42.42 }); // 49.9 - 15%
+        to(coupon).wasCalled();
+        to(cart.total).be(42.42);
+    });
+    scenario("Usuário remove item e carrinho fica vazio", () => {
+        cart.remove("Camiseta");
+        cart.respondsWith({ items: [], total: 0 });
+        to(cart.items).have("length");
+        to(cart.total).be(0);
+    });
+    scenario("Usuário não logado tenta finalizar compra", () => {
+        user.respondsWith({ loggedIn: false });
+        const checkout = standIn();
+        checkout.respondsWith({ error: "LOGIN_REQUIRED", status: 401 });
+        to(checkout.status).be(401);
+    });
+});
+// =============================================================================
+// 🛡️ CAMADA IMPERATIVA: Integração com Gateway de Pagamento
+// =============================================================================
+// Aqui verificamos contratos rígidos com sistemas externos.
+// A linguagem é autoritária: ensure, verify, check.
+ensure("Conformidade com Gateway de Pagamento v2.1", () => {
+    const paymentGateway = stub();
+    const transactionLogger = stub();
+    initAll(() => {
+        // Setup de infraestrutura
+        paymentGateway.process.forceReturn({
+            status: 200,
+            transactionId: "tx_abc123",
+            timestamp: "2026-01-01T00:00:00Z",
+        });
+        transactionLogger.log.forceReturn(true);
+    });
+    reset(() => {
+        // Limpa estado entre testes para garantir contagens precisas
+        paymentGateway.clear();
+        transactionLogger.clear();
+    });
+    check("Transação bem-sucedida retorna status 200", () => {
+        const response = paymentGateway.process({
+            amount: 99.9,
+            currency: "BRL",
+            cardToken: "tok_visa_xxxx",
+        });
+        that(response.status).is(200);
+        that(response.transactionId).matches(/^tx_[a-z0-9]+$/);
+    });
+    check("TransactionId segue padrão RFC do contrato", () => {
+        const response = paymentGateway.process({ amount: 50 });
+        // Validação rigorosa do formato do ID
+        that(response.transactionId).matches(/^tx_[a-z0-9]{6,}$/);
+        that(response.timestamp).matches(/^\d{4}-\d{2}-\d{2}T/);
+    });
+    check("Toda transação deve ser logada para auditoria", () => {
+        paymentGateway.process({ amount: 100 });
+        transactionLogger.log({ event: "PAYMENT_PROCESSED" });
+        that(transactionLogger).triggered();
+        that(transactionLogger).calledWith({ event: "PAYMENT_PROCESSED" });
+    });
+    check("Gateway deve ser acionado exatamente uma vez por request", () => {
+        paymentGateway.process({ amount: 100 });
+        that(paymentGateway).triggeredCount(1);
+    });
+});
+// =============================================================================
+// 🎭 RESUMO: Por que usar os 3 dialetos?
+// =============================================================================
+//
+// | Camada       | Dialeto     | Por quê?                                     |
+// |--------------|-------------|----------------------------------------------|
+// | Cálculos     | Matemático  | Provas de verdades universais, sem estado    |
+// | UX/Jornada   | Narrativo   | Documentação viva legível por PMs            |
+// | Integração   | Imperativo  | Contratos rígidos, conformidade, auditoria   |
+//
+// Cada dialeto expressa a NATUREZA do problema que está resolvendo.
+// A linguagem do teste espelha a linguagem do domínio.

package/dist/examples/sanity.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/sanity.spec.js

@@ -0,0 +1,39 @@
+import { MathDialect, NarrativeDialect, ImperativeDialect, } from "../src/index.js";
+console.log("---------------------------------------------------");
+console.log("🚀 INICIANDO TEST SUITE POLIGLOTA TEMPLATE");
+console.log("---------------------------------------------------");
+// 1. Teste Matemático
+const { axiom, proof, implies, arbitrary } = MathDialect;
+axiom("Teoria dos Conjuntos (Dialeto Matemático)", () => {
+    const f = arbitrary();
+    f.yields(10); // Configuração usando nome matemático
+    proof("f deve mapear para 10", () => {
+        const res = f();
+        implies(res).is(10);
+        implies(f).wasEvaluated();
+    });
+});
+// 2. Teste Narrativo
+const { intend, detail, to, standIn } = NarrativeDialect;
+intend("Autenticação de Usuário (Dialeto Narrativo)", () => {
+    const login = standIn();
+    login.respondsWith(true); // Configuração narrativa
+    detail("login bem sucedido", () => {
+        login("user", "pass");
+        to(login).received("user", "pass");
+        to(login).wasCalled();
+    });
+});
+// 3. Teste Imperativo
+const { ensure, check, that, stub } = ImperativeDialect;
+ensure("Serviço de Pagamento (Dialeto Imperativo)", () => {
+    const api = stub();
+    api.forceReturn(200); // Configuração imperativa
+    check("status da API é 200", () => {
+        const status = api();
+        that(status).is(200);
+        that(api).triggeredCount(1);
+    });
+});
+console.log("\n---------------------------------------------------");
+console.log("🏁 FIM DA EXECUÇÃO");

package/dist/examples/showcase-api.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/showcase-api.spec.js

@@ -0,0 +1,62 @@
+import { ApiSpec } from "../packages/api-test-dialect/index.js";
+/**
+ * 🌐 Teste de Showcase do Dialeto de API
+ * Mostrando todas as funcionalidades integradas:
+ * - GET, POST, PUT, DELETE
+ * - Headers customizados
+ * - Validação de Status Code
+ * - Validação de Schema (Nominal/Semântica)
+ */
+async function runShowcase() {
+    const BASE_URL = "https://jsonplaceholder.typicode.com";
+    console.log("\n--- 🚀 INICIANDO SHOWCASE DE FUNCIONALIDADES API ---");
+    try {
+        // 1. Teste GET Simples
+        await ApiSpec.define("1. Buscar Post Único (GET)")
+            .from(BASE_URL)
+            .get("/posts/1")
+            .shouldReturn(200)
+            .matchingSchema({
+            id: 1,
+            userId: 1,
+            title: "string",
+            body: "string"
+        })
+            .run();
+        // 2. Teste POST com Body e Header
+        await ApiSpec.define("2. Criar Novo Recurso (POST)")
+            .from(BASE_URL)
+            .header("Content-Type", "application/json; charset=UTF-8")
+            .header("X-Custom-Header", "vibe2founderPower")
+            .post("/posts", {
+            title: "Showcase Test",
+            body: "Testando todas as features do dialeto",
+            userId: 1
+        })
+            .shouldReturn(201)
+            .run();
+        // 3. Teste PUT (Atualização)
+        await ApiSpec.define("3. Atualizar Recurso (PUT)")
+            .from(BASE_URL)
+            .put("/posts/1", {
+            id: 1,
+            title: "Título Atualizado",
+            body: "Conteúdo atualizado via PUT",
+            userId: 1
+        })
+            .shouldReturn(200)
+            .run();
+        // 4. Teste DELETE 
+        await ApiSpec.define("4. Remover Recurso (DELETE)")
+            .from(BASE_URL)
+            .delete("/posts/1")
+            .shouldReturn(200)
+            .run();
+        console.log("\n--- ✅ SHOWCASE FINALIZADO COM SUCESSO ---");
+    }
+    catch (err) {
+        console.error("\n--- ❌ SHOWCASE FALHOU ---");
+        // O erro já é logado pelo dialeto no .run()
+    }
+}
+runShowcase();

package/dist/examples/test-api.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/examples/test-api.js

@@ -0,0 +1,32 @@
+import { ApiSpec } from "../packages/api-test-dialect/index.js";
+// Simulating a test run against a public placeholder API (JSONPlaceholder)
+async function runExample() {
+    try {
+        console.log("--- Starting API Dialect Test Example ---");
+        await ApiSpec.define("Get Single Post")
+            .from("https://jsonplaceholder.typicode.com")
+            .get("/posts/1")
+            .shouldReturn(200)
+            .matchingSchema({
+            id: 1,
+            userId: 1,
+            title: "string",
+            body: "string",
+        })
+            .run();
+        await ApiSpec.define("Create New Post")
+            .from("https://jsonplaceholder.typicode.com")
+            .post("/posts", {
+            title: "vibe2founder Test",
+            body: "Building dialects is fun",
+            userId: 1,
+        })
+            .shouldReturn(201)
+            .run();
+        console.log("--- All tests finished successfully ---");
+    }
+    catch (error) {
+        // Error is already logged by the dialect
+    }
+}
+runExample();

package/dist/packages/api-test-dialect/index.d.ts

@@ -0,0 +1,28 @@
+import { HttpMethod, HttpStatusCode, ApiUrl, TestName, SchemaDefinition } from "../../types/api-types.js";
+import { request2httpResponse } from "../reqify/index.js";
+export declare class ApiTestDialect {
+    private _name;
+    private _baseUrl;
+    private _method;
+    private _path;
+    private _body;
+    private _headers;
+    private _expectedStatus;
+    private _expectedSchema;
+    constructor(name: TestName);
+    static define(name: TestName): ApiTestDialect;
+    from(baseUrl: ApiUrl): this;
+    method(cmd: HttpMethod, path: string): this;
+    get(path: string): this;
+    post(path: string, body?: unknown): this;
+    put(path: string, body?: unknown): this;
+    delete(path: string): this;
+    withBody(body: unknown): this;
+    header(key: string, value: string): this;
+    shouldReturn(status: HttpStatusCode): this;
+    matchingSchema(schema: SchemaDefinition): this;
+    run(): Promise<request2httpResponse>;
+    private validate;
+    private validateSchema;
+}
+export declare const ApiSpec: typeof ApiTestDialect;

package/dist/packages/api-test-dialect/index.js

@@ -0,0 +1,102 @@
+import { request2http } from "../reqify/index.js";
+export class ApiTestDialect {
+    _name;
+    _baseUrl = "";
+    _method = "GET";
+    _path = "";
+    _body = null;
+    _headers = {};
+    _expectedStatus = null;
+    _expectedSchema = null;
+    constructor(name) {
+        this._name = name;
+    }
+    static define(name) {
+        return new ApiTestDialect(name);
+    }
+    from(baseUrl) {
+        this._baseUrl = baseUrl;
+        return this;
+    }
+    method(cmd, path) {
+        this._method = cmd;
+        this._path = path;
+        return this;
+    }
+    get(path) {
+        return this.method("GET", path);
+    }
+    post(path, body) {
+        this.method("POST", path);
+        if (body)
+            this.withBody(body);
+        return this;
+    }
+    put(path, body) {
+        this.method("PUT", path);
+        if (body)
+            this.withBody(body);
+        return this;
+    }
+    delete(path) {
+        return this.method("DELETE", path);
+    }
+    withBody(body) {
+        this._body = body;
+        return this;
+    }
+    header(key, value) {
+        this._headers[key] = value;
+        return this;
+    }
+    shouldReturn(status) {
+        this._expectedStatus = status;
+        return this;
+    }
+    matchingSchema(schema) {
+        this._expectedSchema = schema;
+        return this;
+    }
+    async run() {
+        const url = `${this._baseUrl}${this._path}`;
+        console.log(`🚀 [Test: ${this._name}] Running ${this._method} ${url}...`);
+        try {
+            const response = await request2http(url, {
+                method: this._method,
+                headers: this._headers,
+                body: this._body,
+            });
+            this.validate(response);
+            console.log(`✅ [Test: ${this._name}] Passed!`);
+            return response;
+        }
+        catch (error) {
+            console.error(`❌ [Test: ${this._name}] Failed: ${error.message}`);
+            throw error;
+        }
+    }
+    validate(response) {
+        if (this._expectedStatus !== null &&
+            response.status !== this._expectedStatus) {
+            throw new Error(`Expected status ${this._expectedStatus} but got ${response.status}`);
+        }
+        if (this._expectedSchema !== null) {
+            // Basic schema validation logic implemented locally
+            this.validateSchema(response.data, this._expectedSchema);
+        }
+    }
+    validateSchema(data, schema) {
+        // Simple key-based validation for the dialect example
+        for (const key in schema) {
+            if (!(key in data)) {
+                throw new Error(`Schema validation failed: Missing key "${key}" in response`);
+            }
+            const expectedType = typeof schema[key];
+            const actualType = typeof data[key];
+            if (expectedType !== actualType) {
+                throw new Error(`Schema validation failed: Key "${key}" expected type ${expectedType} but got ${actualType}`);
+            }
+        }
+    }
+}
+export const ApiSpec = ApiTestDialect;

package/dist/packages/reqify/index.d.ts

@@ -0,0 +1,12 @@
+import { HttpMethod, HttpStatusCode, ApiUrl } from "../../types/api-types.js";
+export interface request2httpOptions {
+    method?: HttpMethod;
+    headers?: Record<string, string>;
+    body?: unknown;
+}
+export interface request2httpResponse<T = any> {
+    status: HttpStatusCode;
+    data: T;
+    headers: Headers;
+}
+export declare const request2http: <T = any>(url: ApiUrl, options?: request2httpOptions) => Promise<request2httpResponse<T>>;

package/dist/packages/reqify/index.js

@@ -0,0 +1,24 @@
+export const request2http = async (url, options = {}) => {
+    const { method = "GET", headers = {}, body } = options;
+    const response = await fetch(url, {
+        method,
+        headers: {
+            "Content-Type": "application/json",
+            ...headers,
+        },
+        body: body ? JSON.stringify(body) : undefined,
+    });
+    let data;
+    const contentType = response.headers.get("content-type");
+    if (contentType && contentType.includes("application/json")) {
+        data = await response.json();
+    }
+    else {
+        data = await response.text();
+    }
+    return {
+        status: response.status,
+        data: data,
+        headers: response.headers,
+    };
+};

package/dist/src/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env bun
+/**
+ * 🧪 tests2dialects Test Runner
+ * Visual estilo Vitest com cronômetro e cores
+ */
+export {};