@codexa/cli 9.0.2 → 9.0.4

package/gates/validator.test.ts

@@ -0,0 +1,675 @@
+/**
+ * Comprehensive tests for validateByExtension function from validator.ts
+ *
+ * Tests file content validation by extension:
+ * - TypeScript/JavaScript: requires code structure keywords (export, import, function, etc.)
+ * - TSX/JSX: requires code structure AND (<  or export for components)
+ * - CSS/SCSS/SASS: requires { and :
+ * - JSON: must parse successfully
+ * - SQL: requires SELECT, INSERT, UPDATE, DELETE, CREATE, ALTER, or DROP (case insensitive)
+ * - Python: requires def, class, import, or from
+ * - Go: requires package declaration
+ * - Markdown: requires >= 50 characters after trim
+ * - Unknown extensions: always valid (no validation)
+ *
+ * Total: 91 tests covering validation rules, edge cases, and real-world samples
+ */
+import { describe, it, expect } from "bun:test";
+import { validateByExtension, enforceGate, validateGate, type FileValidationResult } from "./validator";
+import { GateError } from "../errors";
+
+describe("validateByExtension", () => {
+  describe("TypeScript/JavaScript files", () => {
+    it("should accept .ts file with export function", () => {
+      const result = validateByExtension(".ts", "export function foo() { return 1; }");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .ts file with import statement", () => {
+      const result = validateByExtension(".ts", 'import { bar } from "baz";');
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .ts file with class declaration", () => {
+      const result = validateByExtension(".ts", "class Foo { constructor() {} }");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should reject .ts file with only comments", () => {
+      const result = validateByExtension(".ts", "// hello world\n// nothing here");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("sem declaracoes validas");
+    });
+
+    it("should reject .tsx file with only JSX (no code structure)", () => {
+      // TSX/JSX require BOTH code structure (export/function/etc) AND JSX
+      const result = validateByExtension(".tsx", "<div>hello</div>");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("sem declaracoes validas");
+    });
+
+    it("should accept .tsx file with export default", () => {
+      const result = validateByExtension(".tsx", "export default function App() { return null; }");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should reject .tsx file without JSX or export", () => {
+      // First check is code structure - fails before JSX check
+      const result = validateByExtension(".tsx", "// just a comment");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("sem declaracoes validas");
+    });
+
+    it("should accept .js file with const declaration", () => {
+      const result = validateByExtension(".js", "const x = 1;");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .jsx file with JSX component and export", () => {
+      // JSX files need code structure keywords, not just JSX
+      const result = validateByExtension(".jsx", "export const Component = () => <div />;");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .ts file with interface", () => {
+      const result = validateByExtension(".ts", "interface User { id: number; }");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .ts file with type alias", () => {
+      const result = validateByExtension(".ts", "type UserId = string;");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .js file with let declaration", () => {
+      const result = validateByExtension(".js", "let count = 0;");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .js file with var declaration", () => {
+      const result = validateByExtension(".js", "var name = 'test';");
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe("CSS/SCSS/SASS files", () => {
+    it("should accept .css file with valid rule", () => {
+      const result = validateByExtension(".css", ".btn { color: red; }");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should reject .css file with only text", () => {
+      const result = validateByExtension(".css", "just text no rules");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("CSS sem regras validas");
+    });
+
+    it("should reject .css file with only opening brace", () => {
+      const result = validateByExtension(".css", "{ something }");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("CSS sem regras validas");
+    });
+
+    it("should reject .css file with only colon", () => {
+      const result = validateByExtension(".css", "color: red");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("CSS sem regras validas");
+    });
+
+    it("should accept .scss file with nested rules", () => {
+      const result = validateByExtension(".scss", ".parent { .child { color: blue; } }");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .sass file with indented syntax and colon", () => {
+      // SASS still needs braces and colons for validation
+      const result = validateByExtension(".sass", ".container { color: green; }");
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe("JSON files", () => {
+    it("should accept .json file with valid JSON object", () => {
+      const result = validateByExtension(".json", '{"key": "value"}');
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .json file with valid JSON array", () => {
+      const result = validateByExtension(".json", '[1, 2, 3]');
+      expect(result.valid).toBe(true);
+    });
+
+    it("should reject .json file with invalid JSON", () => {
+      const result = validateByExtension(".json", "{invalid json}");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("JSON invalido");
+    });
+
+    it("should reject .json file with trailing comma", () => {
+      const result = validateByExtension(".json", '{"key": "value",}');
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("JSON invalido");
+    });
+  });
+
+  describe("SQL files", () => {
+    it("should accept .sql file with SELECT statement", () => {
+      const result = validateByExtension(".sql", "SELECT * FROM users;");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .sql file with CREATE TABLE", () => {
+      const result = validateByExtension(".sql", "CREATE TABLE foo (id INT);");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .sql file with lowercase select", () => {
+      const result = validateByExtension(".sql", "select id from posts;");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .sql file with INSERT statement", () => {
+      const result = validateByExtension(".sql", "INSERT INTO users (name) VALUES ('Alice');");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .sql file with UPDATE statement", () => {
+      const result = validateByExtension(".sql", "UPDATE users SET active = 1;");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .sql file with DELETE statement", () => {
+      const result = validateByExtension(".sql", "DELETE FROM logs WHERE date < '2020-01-01';");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .sql file with ALTER statement", () => {
+      const result = validateByExtension(".sql", "ALTER TABLE users ADD COLUMN email TEXT;");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .sql file with DROP statement", () => {
+      const result = validateByExtension(".sql", "DROP TABLE temp_data;");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should reject .sql file with only comment", () => {
+      const result = validateByExtension(".sql", "-- just a comment");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("SQL sem statements validos");
+    });
+  });
+
+  describe("Python files", () => {
+    it("should accept .py file with function definition", () => {
+      const result = validateByExtension(".py", "def foo():\n    pass");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .py file with class definition", () => {
+      const result = validateByExtension(".py", "class Bar:\n    pass");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .py file with import statement", () => {
+      const result = validateByExtension(".py", "import os");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .py file with from import", () => {
+      const result = validateByExtension(".py", "from datetime import datetime");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should reject .py file with only variable assignment", () => {
+      const result = validateByExtension(".py", "x = 1");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("Python sem definicoes");
+    });
+
+    it("should reject .py file with only comment", () => {
+      const result = validateByExtension(".py", "# just a comment");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("Python sem definicoes");
+    });
+  });
+
+  describe("Go files", () => {
+    it("should accept .go file with package declaration", () => {
+      const result = validateByExtension(".go", "package main\n\nfunc main() {}");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .go file with package declaration only", () => {
+      const result = validateByExtension(".go", "package utils");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should reject .go file without package declaration", () => {
+      const result = validateByExtension(".go", "func main() {}");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("Go sem declaracao package");
+    });
+  });
+
+  describe("Markdown files", () => {
+    it("should accept .md file with 50+ characters", () => {
+      const content = "# Title\n\nThis is a markdown document with enough content to be valid.";
+      const result = validateByExtension(".md", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should reject .md file with less than 50 characters", () => {
+      const result = validateByExtension(".md", "# Short");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("Markdown muito curto");
+    });
+
+    it("should accept .md file with exactly 50 characters", () => {
+      const content = "1234567890123456789012345678901234567890123456789";
+      const result = validateByExtension(".md", content);
+      expect(result.valid).toBe(false); // 49 chars after trim
+    });
+
+    it("should accept .md file with 51 characters", () => {
+      const content = "12345678901234567890123456789012345678901234567890X";
+      const result = validateByExtension(".md", content);
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe("Unknown extensions", () => {
+    it("should accept .yaml file with any content", () => {
+      const result = validateByExtension(".yaml", "key: value");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .txt file with any content", () => {
+      const result = validateByExtension(".txt", "plain text");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .html file with any content", () => {
+      const result = validateByExtension(".html", "<html></html>");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .xml file with any content", () => {
+      const result = validateByExtension(".xml", "<root></root>");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept .env file with any content", () => {
+      const result = validateByExtension(".env", "NODE_ENV=production");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept unknown extension with empty content", () => {
+      const result = validateByExtension(".xyz", "");
+      expect(result.valid).toBe(true);
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle whitespace-only content correctly for .ts", () => {
+      const result = validateByExtension(".ts", "   \n\n   ");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("sem declaracoes validas");
+    });
+
+    it("should handle multiline .ts with comments and code", () => {
+      const content = `
+        // This is a comment
+        export const value = 42;
+        // Another comment
+      `;
+      const result = validateByExtension(".ts", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .tsx with JSX spread", () => {
+      const result = validateByExtension(".tsx", "const App = () => <div {...props} />;");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .json with nested objects", () => {
+      const content = '{"user": {"name": "Alice", "age": 30}}';
+      const result = validateByExtension(".json", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .sql with mixed case", () => {
+      const result = validateByExtension(".sql", "SeLeCt * FrOm UsErS;");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .css with media queries", () => {
+      const content = "@media (min-width: 768px) { .container { width: 100%; } }";
+      const result = validateByExtension(".css", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .py with async def", () => {
+      const result = validateByExtension(".py", "async def fetch(): pass");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle extension with no leading dot", () => {
+      // Function doesn't validate extension format, treats "ts" as unknown extension
+      const result = validateByExtension("ts", "export const x = 1;");
+      expect(result.valid).toBe(true); // Passes as unknown extension (no validation)
+    });
+
+    it("should handle uppercase extension", () => {
+      const result = validateByExtension(".TS", "export const x = 1;");
+      expect(result.valid).toBe(true); // Should work if toLowerCase() is applied
+    });
+  });
+
+  describe("Additional edge cases", () => {
+    it("should handle .tsx with JSX but missing code structure", () => {
+      const result = validateByExtension(".tsx", "const x = <div>test</div>;");
+      expect(result.valid).toBe(true); // Has 'const' keyword
+    });
+
+    it("should handle .tsx with export and no JSX", () => {
+      const result = validateByExtension(".tsx", "export const API_URL = 'https://api.example.com';");
+      expect(result.valid).toBe(true); // Has both export and code structure
+    });
+
+    it("should handle .jsx with only JSX syntax (no valid structure)", () => {
+      const result = validateByExtension(".jsx", "<div><span>Hello</span></div>");
+      expect(result.valid).toBe(false);
+      expect(result.reason).toContain("sem declaracoes validas");
+    });
+
+    it("should handle .css with only selector (no properties)", () => {
+      const result = validateByExtension(".css", ".btn { }");
+      expect(result.valid).toBe(false); // Has { but no :
+    });
+
+    it("should handle .css with CSS variables", () => {
+      const result = validateByExtension(".css", ":root { --primary-color: blue; }");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .json with null value", () => {
+      const result = validateByExtension(".json", '{"value": null}');
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .json with boolean values", () => {
+      const result = validateByExtension(".json", '{"enabled": true, "debug": false}');
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .json with number value", () => {
+      const result = validateByExtension(".json", '123');
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .json with string value", () => {
+      const result = validateByExtension(".json", '"hello world"');
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .sql with comment before statement", () => {
+      const result = validateByExtension(".sql", "-- Get all users\nSELECT * FROM users;");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .sql with multiple statements", () => {
+      const content = "DROP TABLE IF EXISTS users;\nCREATE TABLE users (id INT);";
+      const result = validateByExtension(".sql", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .py with decorator", () => {
+      const result = validateByExtension(".py", "@property\ndef name(self):\n    pass");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .py with lambda", () => {
+      const result = validateByExtension(".py", "square = lambda x: x * x");
+      expect(result.valid).toBe(false); // No def, class, import, or from
+    });
+
+    it("should handle .py with multiline import", () => {
+      const content = "from collections import (\n    Counter,\n    OrderedDict\n)";
+      const result = validateByExtension(".py", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .go with multiple imports", () => {
+      const content = 'package main\n\nimport (\n    "fmt"\n    "os"\n)';
+      const result = validateByExtension(".go", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .go with package comment", () => {
+      const content = "// Package utils provides utilities\npackage utils";
+      const result = validateByExtension(".go", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .md with exactly 50 characters after trim", () => {
+      const content = "01234567890123456789012345678901234567890123456789"; // 50 chars
+      const result = validateByExtension(".md", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .md with 49 characters after trim", () => {
+      const content = "0123456789012345678901234567890123456789012345678"; // 49 chars
+      const result = validateByExtension(".md", content);
+      expect(result.valid).toBe(false);
+    });
+
+    it("should handle .md with whitespace padding", () => {
+      const content = "   " + "x".repeat(50) + "   "; // 50 chars after trim
+      const result = validateByExtension(".md", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .ts with multiple exports on one line", () => {
+      const result = validateByExtension(".ts", "export { foo, bar, baz };");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .ts with export default", () => {
+      const result = validateByExtension(".ts", "export default class App {}");
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .ts with re-export", () => {
+      const result = validateByExtension(".ts", 'export * from "./types";');
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .js with dynamic import", () => {
+      const result = validateByExtension(".js", 'const module = await import("./utils");');
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .css with @import", () => {
+      const result = validateByExtension(".css", '@import url("reset.css"); .btn { color: red; }');
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle .css with @keyframes", () => {
+      const content = "@keyframes fadeIn { from { opacity: 0; } to { opacity: 1; } }";
+      const result = validateByExtension(".css", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should handle empty extension", () => {
+      const result = validateByExtension("", "some content");
+      expect(result.valid).toBe(true); // Unknown extension
+    });
+  });
+
+  describe("Real-world code samples", () => {
+    it("should accept realistic React component", () => {
+      const content = `
+import React from 'react';
+
+export default function Button({ label, onClick }) {
+  return (
+    <button onClick={onClick} className="btn">
+      {label}
+    </button>
+  );
+}
+      `;
+      const result = validateByExtension(".tsx", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept realistic TypeScript utility", () => {
+      const content = `
+export function formatDate(date: Date): string {
+  return date.toISOString().split('T')[0];
+}
+
+export const DEFAULT_LOCALE = 'en-US';
+      `;
+      const result = validateByExtension(".ts", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept realistic CSS module", () => {
+      const content = `
+.container {
+  display: flex;
+  flex-direction: column;
+  padding: 1rem;
+}
+
+.container .item {
+  margin-bottom: 0.5rem;
+}
+      `;
+      const result = validateByExtension(".css", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept realistic SQL migration", () => {
+      const content = `
+-- Migration: Add users table
+CREATE TABLE users (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  email TEXT NOT NULL UNIQUE,
+  created_at TEXT DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_users_email ON users(email);
+      `;
+      const result = validateByExtension(".sql", content);
+      expect(result.valid).toBe(true);
+    });
+
+    it("should accept realistic Python class", () => {
+      const content = `
+class User:
+    def __init__(self, name, email):
+        self.name = name
+        self.email = email
+
+    def get_display_name(self):
+        return self.name.title()
+      `;
+      const result = validateByExtension(".py", content);
+      expect(result.valid).toBe(true);
+    });
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════
+// enforceGate() tests — verifica que lança GateError em vez de process.exit
+// ═══════════════════════════════════════════════════════════════
+
+describe("enforceGate", () => {
+  it("should throw GateError when gate fails", () => {
+    // "task-done" with no taskId makes "task-is-running" fail immediately
+    // without needing DB access
+    try {
+      enforceGate("task-done", {});
+      expect(true).toBe(false); // Should not reach here
+    } catch (e) {
+      expect(e instanceof GateError).toBe(true);
+      const ge = e as GateError;
+      expect(ge.message).toContain("BLOQUEADO:");
+      expect(ge.message).toContain("Resolva:");
+      expect(ge.exitCode).toBe(1);
+    }
+  });
+
+  it("should not throw for unknown command (no gates defined)", () => {
+    // Unknown commands have no gate checks, so they pass
+    expect(() => enforceGate("nonexistent-command")).not.toThrow();
+  });
+
+  it("should return a GateResult from validateGate", () => {
+    const result = validateGate("task-done", {});
+    expect(result.passed).toBe(false);
+    expect(result.reason).toBeDefined();
+    expect(result.resolution).toBeDefined();
+  });
+});
+
+// ═══════════════════════════════════════════════════════════════
+// v9.3: Recovery Strategies
+// ═══════════════════════════════════════════════════════════════
+
+describe("Recovery Strategies (P3.3)", () => {
+  it("GateError should carry recovery suggestion", () => {
+    try {
+      // "task-done" with no taskId fails on "task-is-running"
+      // task-is-running has no recovery strategy, so recovery should be undefined
+      enforceGate("task-done", {});
+      expect(true).toBe(false);
+    } catch (e) {
+      const ge = e as GateError;
+      expect(ge instanceof GateError).toBe(true);
+      // task-is-running has no recovery strategy
+      expect(ge.recovery).toBeUndefined();
+    }
+  });
+
+  it("validateGate should return recovery for checkpoint-filled failure", () => {
+    // Simulate a task-done call where task-is-running passes but checkpoint fails
+    // We pass taskId to skip task-is-running (it needs DB), so we test checkpoint directly
+    const result = validateGate("task-done", { taskId: null });
+    // Without taskId, task-is-running fails first (no recovery for it)
+    expect(result.passed).toBe(false);
+  });
+
+  it("GateError recovery field should have correct structure when present", () => {
+    const { RecoverySuggestion } = require("../errors");
+    const recovery = {
+      diagnostic: "Erros TypeScript encontrados:\nsrc/foo.ts:10 - TS2322",
+      steps: [
+        "Corrija os erros de tipo listados",
+        "Verifique imports e definicoes de tipo",
+      ],
+      command: "bunx tsc --noEmit",
+    };
+
+    const err = new GateError("test reason", "test resolution", "typecheck-pass", recovery);
+    expect(err.recovery).toBeDefined();
+    expect(err.recovery!.diagnostic).toContain("Erros TypeScript");
+    expect(err.recovery!.steps).toHaveLength(2);
+    expect(err.recovery!.steps[0]).toContain("Corrija");
+    expect(err.recovery!.command).toBe("bunx tsc --noEmit");
+  });
+
+  it("GateError without recovery should have undefined recovery", () => {
+    const err = new GateError("test reason", "test resolution", "unknown-gate");
+    expect(err.recovery).toBeUndefined();
+  });
+
+  it("validateGate for unknown command should pass with no recovery", () => {
+    const result = validateGate("nonexistent", {});
+    expect(result.passed).toBe(true);
+    expect(result.recovery).toBeUndefined();
+  });
+});