Suite de Tests Canónicos FARO Connect MVP

{
  "company_id": "10000000-0000-0000-0000-000000000001",
  "period_start": "2026-05-01",
  "period_end": "2026-05-31",
  "expected_tensions": [
    {
      "tension_code": "TNS-001",
      "name": "Crecimiento no rentable",
      "expected_rule_code": "RULE-TNS-001",
      "minimum_priority_score": 90,
      "severity": "critical",
      "expected_actions": ["ACT-COM-001", "ACT-COM-002", "ACT-COM-003"],
      "expected_evidence": ["EVD-007", "EVD-012"]
    },
    {
      "tension_code": "TNS-004",
      "name": "Venta sin conversión a caja",
      "expected_rule_code": "RULE-TNS-004",
      "minimum_priority_score": 80,
      "severity": "critical",
      "expected_actions": ["ACT-FIN-001", "ACT-FIN-002", "ACT-FIN-003"],
      "expected_evidence": ["EVD-011", "EVD-006", "EVD-012"]
    },
    {
      "tension_code": "TNS-006",
      "name": "Stock crítico en productos de alta rotación",
      "expected_rule_code": "RULE-TNS-006",
      "minimum_priority_score": 70,
      "severity": "high",
      "expected_actions": ["ACT-STK-001", "ACT-STK-002"],
      "expected_evidence": ["EVD-005", "EVD-002"]
    },
    {
      "tension_code": "TNS-007",
      "name": "Stock inmovilizado",
      "expected_rule_code": "RULE-TNS-007",
      "minimum_priority_score": 60,
      "severity": "high",
      "expected_actions": ["ACT-STK-003", "ACT-COM-001"],
      "expected_evidence": ["EVD-010", "EVD-012"]
    },
    {
      "tension_code": "TNS-009",
      "name": "Acciones vencidas",
      "expected_rule_code": "RULE-TNS-009",
      "minimum_priority_score": 70,
      "severity": "high",
      "expected_actions": ["ACT-OPS-001", "ACT-DIR-001"],
      "expected_evidence": ["EVD-004", "EVD-012"]
    },
    {
      "tension_code": "TNS-010",
      "name": "Acciones sin evidencia",
      "expected_rule_code": "RULE-TNS-010",
      "minimum_priority_score": 70,
      "severity": "high",
      "expected_actions": ["ACT-OPS-002", "ACT-DIR-001"],
      "expected_evidence": ["EVD-004", "EVD-012"]
    }
  ]
}

{
  "expected_counts": {
    "tension_definitions": 30,
    "action_definitions": 30,
    "evidence_definitions": 12
  },
  "must_exist": {
    "tensions": ["TNS-001", "TNS-004", "TNS-006", "TNS-007", "TNS-009", "TNS-010"],
    "actions": ["ACT-COM-001", "ACT-FIN-001", "ACT-STK-001", "ACT-OPS-001", "ACT-OPS-002", "ACT-DIR-001", "ACT-DQ-001"],
    "evidence": ["EVD-001", "EVD-002", "EVD-004", "EVD-007", "EVD-010", "EVD-011", "EVD-012"]
  },
  "critical_evidence": ["EVD-007", "EVD-012"],
  "weak_evidence": ["EVD-004"]
}

import { describe, expect, it } from "vitest";
import { evaluateConditionGroup } from "../src/engine/conditionEvaluator";

const snapshots: any = {
  "KPI-SAL-001": { value: 36102650, deltaPct: 0.1798, confidenceScore: 89, status: "ok" },
  "KPI-SAL-002": { value: 0.213, deltaPct: -0.2392, confidenceScore: 87, status: "critical" },
  "KPI-SAL-003": { value: 0.123, deltaPct: 0.9838, confidenceScore: 86, status: "critical" }
};

describe("Condition Evaluator", () => {
  it("passes all conditions for growth not profitable", () => {
    const result = evaluateConditionGroup(
      {
        all: [
          { kpi: "KPI-SAL-001", metric: "delta_pct", operator: ">=", value: 0.10 },
          { kpi: "KPI-SAL-002", metric: "delta_pct", operator: "<=", value: -0.10 },
          { kpi: "KPI-SAL-003", metric: "delta_pct", operator: ">=", value: 0.30 }
        ]
      },
      snapshots
    );
    expect(result.passed).toBe(true);
  });

  it("supports any condition group", () => {
    const result = evaluateConditionGroup(
      { any: [{ kpi: "KPI-SAL-003", metric: "value", operator: ">=", value: 0.10 }] },
      snapshots
    );
    expect(result.passed).toBe(true);
  });

  it("supports none condition group", () => {
    const result = evaluateConditionGroup(
      { none: [{ kpi: "KPI-SAL-002", metric: "value", operator: ">=", value: 0.30 }] },
      snapshots
    );
    expect(result.passed).toBe(true);
  });
});

import { describe, expect, it } from "vitest";
import { calculateSeverity } from "../src/engine/severityCalculator";
import { calculateScoreImpact } from "../src/services/scoreImpactService";

describe("Severity and Score Impact", () => {
  it("escalates to critical when escalation condition passes", () => {
    const rule: any = {
      ruleBody: {
        severity: {
          default: "high",
          escalation: [
            {
              when: {
                all: [
                  { kpi: "KPI-SAL-002", metric: "value", operator: "<=", value: 0.22 },
                  { kpi: "KPI-SAL-003", metric: "value", operator: ">=", value: 0.10 }
                ]
              },
              set: "critical"
            }
          ]
        }
      }
    };

    const severity = calculateSeverity(rule, {
      "KPI-SAL-002": { value: 0.213 },
      "KPI-SAL-003": { value: 0.123 }
    } as any);

    expect(severity).toBe("critical");
  });

  it("calculates score impact with critical multiplier and cap", () => {
    const impact = calculateScoreImpact({
      base: -8,
      max: -12,
      severity: "critical"
    });

    expect(impact).toBeLessThanOrEqual(-8);
    expect(impact).toBeGreaterThanOrEqual(-12);
  });
});

import { describe, expect, it } from "vitest";
import { withTestDbContext } from "../src/helpers/dbTestContext";
import { runEvaluation } from "../src/services/evaluationService";

const COMPANY_ID = "10000000-0000-0000-0000-000000000001";
const USER_ID = "12000000-0000-0000-0000-000000000001";

describe("Idempotency", () => {
  it("does not duplicate open tensions and actions when run twice", async () => {
    await withTestDbContext(
      {
        companyId: COMPANY_ID,
        userId: USER_ID,
        roleCodes: ["integration_service", "faro_owner", "company_admin"]
      },
      async (client) => {
        const first = await runEvaluation(client, {
          companyId: COMPANY_ID, userId: USER_ID,
          roleCodes: ["integration_service", "faro_owner", "company_admin"],
          periodStart: "2026-05-01", periodEnd: "2026-05-31",
          dryRun: false, createActions: true
        });

        const second = await runEvaluation(client, {
          companyId: COMPANY_ID, userId: USER_ID,
          roleCodes: ["integration_service", "faro_owner", "company_admin"],
          periodStart: "2026-05-01", periodEnd: "2026-05-31",
          dryRun: false, createActions: true
        });

        expect(first.rulesTriggered).toBeGreaterThan(0);
        expect(second.rulesTriggered).toBeGreaterThan(0);

        expect(second.tensionsCreated).toBe(0);
        expect(second.tensionsUpdated).toBeGreaterThanOrEqual(1);
        expect(second.actionsCreated).toBe(0);
      }
    );
  });
});

import { describe, expect, it } from "vitest";
import { testPool } from "../src/helpers/dbTestContext";

const COMPANY_A = "10000000-0000-0000-0000-000000000001";
const COMPANY_B = "20000000-0000-0000-0000-000000000001";

describe("RLS Multiempresa", () => {
  it("Tenant A cannot see Tenant B data", async () => {
    const client = await testPool.connect();
    try {
      await client.query("BEGIN");
      await client.query(`SELECT set_config('app.company_id', $1, true)`, [COMPANY_A]);
      await client.query(`SELECT set_config('app.user_id', $1, true)`, ["12000000-0000-0000-0000-000000000001"]);
      await client.query(`SELECT set_config('app.role_codes', $1, true)`, ["director"]);

      const result = await client.query(`SELECT DISTINCT company_id FROM faro.kpi_snapshots`);

      expect(result.rows.every((row) => row.company_id === COMPANY_A)).toBe(true);

      await client.query("ROLLBACK");
    } finally {
      client.release();
    }
  });

  it("without context returns no operational rows", async () => {
    const client = await testPool.connect();
    try {
      await client.query("BEGIN");
      await client.query(`RESET app.company_id`);
      await client.query(`RESET app.user_id`);
      await client.query(`RESET app.role_codes`);

      const result = await client.query(`SELECT * FROM faro.tensions`);
      expect(result.rows.length).toBe(0);

      await client.query("ROLLBACK");
    } finally {
      client.release();
    }
  });
});

import { describe, expect, it } from "vitest";
import fs from "node:fs";
import path from "node:path";

function readFileIfExists(filePath: string): string {
  if (!fs.existsSync(filePath)) return "";
  return fs.readFileSync(filePath, "utf8");
}

describe("No hardcoded catalog regression", () => {
  it("actionService does not contain ACTION_CATALOG hardcoded object", () => {
    const content = readFileIfExists(path.resolve("src/services/actionService.ts"));
    expect(content).not.toContain("const ACTION_CATALOG");
    expect(content).not.toContain("ACTION_CATALOG:");
  });

  it("engine uses canonical catalog repositories", () => {
    const evaluationService = readFileIfExists(path.resolve("src/services/evaluationService.ts"));
    const actionService = readFileIfExists(path.resolve("src/services/actionService.ts"));

    expect(evaluationService).toContain("getActiveTensionDefinition");
    expect(actionService).toContain("getActiveActionDefinitionsByCodes");
    expect(actionService).toContain("buildEvidenceRequirementsPayload");
  });
});

name: FARO Canonical Catalog Tests

on:
  pull_request:
    paths:
      - "src/**"
      - "tests/**"
      - "rules/**"
      - "migrations/**"
      - "seeds/**"

jobs:
  canonical-tests:
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_USER: faro_app
          POSTGRES_PASSWORD: password
          POSTGRES_DB: faro_test
        ports:
          - 5432:5432
        options: >-
          --health-cmd="pg_isready -U faro_app -d faro_test"
          --health-interval=10s
          --health-timeout=5s
          --health-retries=5

    env:
      DATABASE_URL: postgresql://faro_app:password@localhost:5432/faro_test

    steps:
      - uses: actions/checkout@v4

      - uses: actions/setup-node@v4
        with:
          node-version: 22

      - run: npm ci

      - name: Typecheck
        run: npm run typecheck

      - name: Run migrations
        run: npm run db:migrate:test

      - name: Seed canonical catalogs
        run: npm run db:seed:catalogs

      - name: Seed demo company
        run: npm run db:seed:demo

      - name: Patch demo canonical alignment
        run: npm run db:patch:demo-canonical

      - name: Validate YAML rules
        run: npm run validate

      - name: Run base rule tests
        run: npm run test:rules

      - name: Run canonical catalog tests
        run: npm run test:canonical

      - name: Run full MVP test suite
        run: npm run test