promptfoo--promptfoo/test/models/modelAudit.test.ts

import { describe, expect, it, vi } from 'vitest';
import ModelAudit from '../../src/models/modelAudit';

import type { ModelAuditScanResults } from '../../src/types/modelAudit';

// Mock the database
vi.mock('../../src/database', () => ({
  getDb: () => ({
    insert: () => ({
      values: () => ({
        run: vi.fn().mockResolvedValue({}),
      }),
    }),
    select: () => ({
      from: () => ({
        where: () => ({
          get: vi.fn().mockResolvedValue(null),
          orderBy: () => ({
            get: vi.fn().mockResolvedValue(null),
          }),
        }),
        orderBy: () => ({
          all: vi.fn().mockResolvedValue([]),
          limit: () => ({
            all: vi.fn().mockResolvedValue([]),
          }),
        }),
      }),
    }),
  }),
}));

describe('ModelAudit', () => {
  describe('hasErrors logic', () => {
    it('should set hasErrors to true when has_errors is true in results', () => {
      const results: ModelAuditScanResults = {
        has_errors: true,
        issues: [{ severity: 'warning', message: 'Test warning' }],
      };

      const audit = new ModelAudit({
        modelPath: '/test/path',
        results,
      });

      expect(audit.hasErrors).toBe(true);
    });

    it('should set hasErrors to true when has_errors is false but critical issues exist', () => {
      const results: ModelAuditScanResults = {
        has_errors: false, // CLI tool incorrectly says no errors
        issues: [
          { severity: 'critical', message: 'Test critical issue' },
          { severity: 'warning', message: 'Test warning' },
        ],
      };

      const audit = new ModelAudit({
        modelPath: '/test/path',
        results,
      });

      expect(audit.hasErrors).toBe(true);
    });

    it('should set hasErrors to true when has_errors is false but error issues exist', () => {
      const results: ModelAuditScanResults = {
        has_errors: false, // CLI tool incorrectly says no errors
        issues: [
          { severity: 'error', message: 'Test error issue' },
          { severity: 'warning', message: 'Test warning' },
        ],
      };

      const audit = new ModelAudit({
        modelPath: '/test/path',
        results,
      });

      expect(audit.hasErrors).toBe(true);
    });

    it('should set hasErrors to true when warning findings exist', () => {
      const results: ModelAuditScanResults = {
        has_errors: false,
        issues: [
          { severity: 'warning', message: 'Test warning' },
          { severity: 'info', message: 'Test info' },
        ],
      };

      const audit = new ModelAudit({
        modelPath: '/test/path',
        results,
      });

      expect(audit.hasErrors).toBe(true);
    });

    it('should set hasErrors to false when has_errors is false and no issues exist', () => {
      const results: ModelAuditScanResults = {
        has_errors: false,
        issues: [],
      };

      const audit = new ModelAudit({
        modelPath: '/test/path',
        results,
      });

      expect(audit.hasErrors).toBe(false);
    });

    it('should set hasErrors to true when failed checks exist without issue rows', () => {
      const results: ModelAuditScanResults = {
        has_errors: false,
        failed_checks: 1,
        issues: [],
        checks: [{ name: 'pickle', status: 'failed', message: 'Check failed' }],
      };

      const audit = new ModelAudit({
        modelPath: '/test/path',
        results,
      });

      expect(audit.hasErrors).toBe(true);
    });

    it('should handle missing issues array gracefully', () => {
      const results: ModelAuditScanResults = {
        has_errors: false,
        // issues not provided
      };

      const audit = new ModelAudit({
        modelPath: '/test/path',
        results,
      });

      expect(audit.hasErrors).toBe(false);
    });

    it('should prioritize explicit hasErrors over computed value', () => {
      const results: ModelAuditScanResults = {
        has_errors: false,
        issues: [{ severity: 'critical', message: 'Test critical issue' }],
      };

      const audit = new ModelAudit({
        modelPath: '/test/path',
        results,
        hasErrors: false, // Explicitly set to false
      });

      // Should still be false because explicit value takes precedence
      expect(audit.hasErrors).toBe(false);
    });
  });

  describe('ModelAudit.create', () => {
    it('should properly set hasErrors in create method with critical issues', async () => {
      const results: ModelAuditScanResults = {
        has_errors: false, // CLI tool incorrectly says no errors
        issues: [{ severity: 'critical', message: 'Test critical issue' }],
      };

      const audit = await ModelAudit.create({
        modelPath: '/test/path',
        results,
      });

      expect(audit.hasErrors).toBe(true);
    });

    it('should properly set hasErrors in create method with error issues', async () => {
      const results: ModelAuditScanResults = {
        has_errors: false, // CLI tool incorrectly says no errors
        issues: [{ severity: 'error', message: 'Test error issue' }],
      };

      const audit = await ModelAudit.create({
        modelPath: '/test/path',
        results,
      });

      expect(audit.hasErrors).toBe(true);
    });

    it('should keep warning findings visible in create method', async () => {
      const results: ModelAuditScanResults = {
        has_errors: false,
        issues: [{ severity: 'warning', message: 'Test warning' }],
      };

      const audit = await ModelAudit.create({
        modelPath: '/test/path',
        results,
      });

      expect(audit.hasErrors).toBe(true);
    });
  });
});