Blame for tests/dna_microarray_audit.test.js

import test from 'node:test';
import assert from 'node:assert/strict';

import {
  detectDnaMicroarrayFormat,
  isDnaMicroarrayContent,
  auditDnaMicroarraySecurity,
  generateDnaMicroarrayFuzzCases,
  synthesizeDnaMicroarrayPolicy,
  DEFAULT_DNA_MICROARRAY_BIOSECURITY_POLICY
} from '../dist/dna/dna_microarray_audit.js';

import {
  applyDnaMicroarrayTransformations,
  synthesizeDnaMicroarrayArtifactPatch,
  synthesizeDnaMicroarrayPatch,
  synthesizeAndInjectPatch
} from '../dist/patch/patch_engine.js';

import {
  MockDnaMicroarrayHarness,
  runDnaMicroarrayAttackSimulation
} from '../dist/sandbox/canary_sandbox.js';

import {
  executeCanaryVerification,
  executeDnaMicroarrayCanaryVerification,
  runDnaMicroarrayCanary
} from '../dist/sandbox/canary_runner.js';

import { createVulnForgeServer } from '../dist/mcp/server.js';
import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';

// --- 1. Artifact Format Detection & Content Identification ---

test('DNA Microarray Biosecurity Gate: Accurately detects formats and content', () => {
  // DNA_MICROARRAY_ORDER_JSON
  const orderJson = JSON.stringify({
    dna_microarray_order: 'SYNTH-9901',
    sequence: 'ATGCGATCGATCGATCGATC',
    screen_window_bp: 250,
    homology_e_value: 1e-12
  });
  assert.equal(detectDnaMicroarrayFormat(orderJson), 'DNA_MICROARRAY_ORDER_JSON');
  assert.equal(isDnaMicroarrayContent(orderJson), true);

  // SYNTHETIC_GENE_FASTA
  const fastaContent = '>synthetic_construct_01\nATGCGATCGATCGATCGATCGATCGATCGATCGATC\n';
  assert.equal(detectDnaMicroarrayFormat(fastaContent), 'SYNTHETIC_GENE_FASTA');
  assert.equal(isDnaMicroarrayContent(fastaContent), true);

  // DIGITAL_WATERMARK_SPEC
  const watermarkSpec = `
    biosecurity_watermark:
      algorithm: Ed25519
      watermark_signature: attested
      watermark_payload: active
  `;
  assert.equal(detectDnaMicroarrayFormat(watermarkSpec), 'DIGITAL_WATERMARK_SPEC');
  assert.equal(isDnaMicroarrayContent(watermarkSpec), true);

  // PATHOGEN_SCREENING_REPORT_JSON
  const screeningReport = JSON.stringify({
    pathogen_screening_report: true,
    select_agent_match: false,
    assembly_screening: true
  });
  assert.equal(detectDnaMicroarrayFormat(screeningReport), 'PATHOGEN_SCREENING_REPORT_JSON');
  assert.equal(isDnaMicroarrayContent(screeningReport), true);

  // MICROARRAY_HYBRIDIZATION_MAP
  const spotSpec = JSON.stringify({
    microarray_spot_density_pct: 82.5,
    probe_spot_density: 0.8,
    fluorophore_crosstalk: 0.015,
    hybridization_map: true
  });
  assert.equal(detectDnaMicroarrayFormat(spotSpec), 'MICROARRAY_HYBRIDIZATION_MAP');
  assert.equal(isDnaMicroarrayContent(spotSpec), true);

  // BIOSECURITY_POLICY_JSON
  const policyJson = JSON.stringify({
    dna_microarray_biosecurity: 'POLICY-V1',
    biosecurity_policy: true,
    pathogenHomologyScreening: { enforceSelectAgentScreening: true },
    digitalWatermarkProvenance: { enforceDigitalWatermarking: true }
  });
  assert.equal(detectDnaMicroarrayFormat(policyJson), 'BIOSECURITY_POLICY_JSON');
  assert.equal(isDnaMicroarrayContent(policyJson), true);

  // Foreign / Unknown content
  assert.equal(detectDnaMicroarrayFormat('flux_qubit_calibration: true'), 'UNKNOWN');
  assert.equal(isDnaMicroarrayContent('flux_qubit_calibration: true'), false);
});

// --- 2. Vulnerability Vector Identification (VF-DNAMICRO-001 through 008) ---

test('DNA Microarray Biosecurity Gate: Detects VF-DNAMICRO-001 Pathogen Screening Bypass', async () => {
  const badOrder = JSON.stringify({
    order_id: 'SYNTH-VULN-001',
    sequence: 'ATGCGAATCG',
    screen_window_bp: 120,
    homology_e_value: 0.05
  });
  const res = await auditDnaMicroarraySecurity({ content: badOrder, filePath: 'order.json' });
  assert.equal(res.passed, false);
  assert.ok(res.findings.some(f => f.findingCode === 'VF-DNAMICRO-001'));
  assert.equal(res.findings.find(f => f.findingCode === 'VF-DNAMICRO-001')?.severity, 'CRITICAL');
});

test('DNA Microarray Biosecurity Gate: Detects VF-DNAMICRO-002 Digital Watermark Absence', async () => {
  const badWatermark = JSON.stringify({
    biosecurity_watermark: true,
    watermark_signature_present: false,
    digital_watermark_present: false
  });
  const res = await auditDnaMicroarraySecurity({ content: badWatermark, filePath: 'watermark.json' });
  assert.equal(res.passed, false);
  assert.ok(res.findings.some(f => f.findingCode === 'VF-DNAMICRO-002'));
  assert.equal(res.findings.find(f => f.findingCode === 'VF-DNAMICRO-002')?.severity, 'CRITICAL');
});

test('DNA Microarray Biosecurity Gate: Detects VF-DNAMICRO-003 Customer KYC Attestation Failure', async () => {
  const badKyc = JSON.stringify({
    customer_screening: true,
    kyc_verified: false,
    institutional_kyc_attested: false
  });
  const res = await auditDnaMicroarraySecurity({ content: badKyc, filePath: 'kyc.json' });
  assert.equal(res.passed, false);
  assert.ok(res.findings.some(f => f.findingCode === 'VF-DNAMICRO-003'));
  assert.equal(res.findings.find(f => f.findingCode === 'VF-DNAMICRO-003')?.severity, 'CRITICAL');
});

test('DNA Microarray Biosecurity Gate: Detects VF-DNAMICRO-004 Split-Gene DURC Assembly Coverage', async () => {
  const badDurc = JSON.stringify({
    assembly_screening: true,
    split_gene_coverage_pct: 35.0,
    multi_fragment_assembly: true
  });
  const res = await auditDnaMicroarraySecurity({ content: badDurc, filePath: 'durc.json' });
  assert.equal(res.passed, false);
  assert.ok(res.findings.some(f => f.findingCode === 'VF-DNAMICRO-004'));
  assert.equal(res.findings.find(f => f.findingCode === 'VF-DNAMICRO-004')?.severity, 'HIGH');
});

test('DNA Microarray Biosecurity Gate: Detects VF-DNAMICRO-005 Microarray Spot Density & Fluorophore Crosstalk', async () => {
  const badSpot = JSON.stringify({
    microarray_spot_density_pct: 94.5,
    fluorophore_crosstalk_pct: 4.8
  });
  const res = await auditDnaMicroarraySecurity({ content: badSpot, filePath: 'spot.json' });
  assert.equal(res.passed, false);
  assert.ok(res.findings.some(f => f.findingCode === 'VF-DNAMICRO-005'));
  assert.equal(res.findings.find(f => f.findingCode === 'VF-DNAMICRO-005')?.severity, 'HIGH');
});

test('DNA Microarray Biosecurity Gate: Detects VF-DNAMICRO-006 Codon Optimization Evasion', async () => {
  const badCodon = JSON.stringify({
    codon_optimization: true,
    codon_scrambling_detected: true,
    six_frame_translation_audit: false
  });
  const res = await auditDnaMicroarraySecurity({ content: badCodon, filePath: 'codon.json' });
  assert.equal(res.passed, false);
  assert.ok(res.findings.some(f => f.findingCode === 'VF-DNAMICRO-006'));
  assert.equal(res.findings.find(f => f.findingCode === 'VF-DNAMICRO-006')?.severity, 'HIGH');
});

test('DNA Microarray Biosecurity Gate: Detects VF-DNAMICRO-007 Stale Synthesis Nonce Replay', async () => {
  const badNonce = JSON.stringify({
    synthesis_nonce_validation: true,
    stale_nonce_detected: true,
    certificate_age_seconds: 95000
  });
  const res = await auditDnaMicroarraySecurity({ content: badNonce, filePath: 'nonce.json' });
  assert.equal(res.passed, false);
  assert.ok(res.findings.some(f => f.findingCode === 'VF-DNAMICRO-007'));
  assert.equal(res.findings.find(f => f.findingCode === 'VF-DNAMICRO-007')?.severity, 'HIGH');
});

test('DNA Microarray Biosecurity Gate: Detects VF-DNAMICRO-008 Equipment Fail-Open Posture', async () => {
  const badEquipment = JSON.stringify({
    gene_foundry_id: 'FOUNDRY-BETA',
    fail_open_on_timeout: true,
    fail_closed_on_timeout: false
  });
  const res = await auditDnaMicroarraySecurity({ content: badEquipment, filePath: 'equipment.json' });
  assert.equal(res.passed, false);
  assert.ok(res.findings.some(f => f.findingCode === 'VF-DNAMICRO-008'));
  assert.equal(res.findings.find(f => f.findingCode === 'VF-DNAMICRO-008')?.severity, 'HIGH');
});

// --- 3. Clean Configuration Pass ---

test('DNA Microarray Biosecurity Gate: Clean configuration scores 100/100 PASS', async () => {
  const cleanConfig = JSON.stringify({
    policyVersion: '1.58.0',
    order_id: 'SYNTH-ORD-CLEAN-01',
    screen_window_bp: 250,
    homology_e_value: 1e-12,
    watermark_signature_present: true,
    digital_watermark_present: true,
    kyc_verified: true,
    institutional_kyc_attested: true,
    split_gene_coverage_pct: 8.5,
    spot_density_pct: 80.0,
    fluorophore_crosstalk_pct: 1.5,
    codon_scrambling_detected: false,
    stale_nonce_detected: false,
    certificate_age_seconds: 3600,
    fail_open_on_timeout: false
  });

  const res = await auditDnaMicroarraySecurity({ content: cleanConfig, filePath: 'clean_order.json' });
  assert.equal(res.passed, true);
  assert.equal(res.summary.score, 100);
  assert.equal(res.summary.complianceStatus, 'PASS');
  assert.equal(res.summary.findingsCount, 0);
  assert.equal(res.attestationStatus, 'VERIFIED_SECURE');
});

// --- 4. Policy Synthesis & Fuzz Case Generation ---

test('DNA Microarray Biosecurity Gate: Synthesizes hardening policy and fuzz cases', async () => {
  const badConfig = JSON.stringify({
    screen_window_bp: 120,
    homology_e_value: 0.05,
    watermark_signature_present: false,
    kyc_verified: false,
    split_gene_coverage_pct: 35.0,
    spot_density_pct: 95.0,
    fluorophore_crosstalk_pct: 5.0,
    codon_scrambling_detected: true,
    stale_nonce_detected: true,
    fail_open_on_timeout: true
  });

  const auditRes = await auditDnaMicroarraySecurity({ content: badConfig });
  const policy = synthesizeDnaMicroarrayPolicy('policy.json', auditRes.findings);

  assert.equal(policy.pathogenHomologyScreening.enforceSelectAgentScreening, true);
  assert.equal(policy.pathogenHomologyScreening.minScreeningWindowBp, 200);
  assert.equal(policy.digitalWatermarkProvenance.enforceDigitalWatermarking, true);
  assert.equal(policy.customerKycAttestation.enforceInstitutionalKyc, true);
  assert.equal(policy.durcSplitSynthesisDefense.enforceMultiFragmentAssemblyCheck, true);
  assert.equal(policy.durcSplitSynthesisDefense.maxCumulativePathogenCoveragePct, 10.0);
  assert.equal(policy.microarrayDensityCrosstalk.enforceSpotDensityLimits, true);
  assert.equal(policy.microarrayDensityCrosstalk.maxProbeSpotDensityPct, 85.0);
  assert.equal(policy.codonScramblingDetection.enforceAminoAcidHomologyScreening, true);
  assert.equal(policy.synthesisNonceLifecycle.enforceFreshSynthesisNonces, true);
  assert.equal(policy.equipmentFailClosed.enforceFailClosedSynthesisAbort, true);

  const fuzzCases = generateDnaMicroarrayFuzzCases();
  assert.equal(fuzzCases.length, 8);
  assert.ok(fuzzCases.every(c => (c.name || c.id) && c.payload && c.expectedStatus));
});

// --- 5. Patch Engine Transformations ---

test('DNA Microarray Biosecurity Gate: Patch engine synthesizes and injects patches', () => {
  const vulnerableCode = `
{
  "screen_window_bp": 120,
  "homology_e_value": 0.05,
  "watermark_signature_present": false,
  "kyc_verified": false,
  "split_gene_coverage_pct": 35.0,
  "spot_density_pct": 94.5,
  "fluorophore_crosstalk_pct": 4.8,
  "codon_scrambling_detected": true,
  "stale_nonce_detected": true,
  "fail_open_on_timeout": true
}
  `;

  const trans = applyDnaMicroarrayTransformations(vulnerableCode);
  assert.ok(trans.changes.length > 0);
  assert.ok(trans.resolvedFindings.includes('VF-DNAMICRO-001'));
  assert.ok(trans.resolvedFindings.includes('VF-DNAMICRO-002'));
  assert.ok(trans.resolvedFindings.includes('VF-DNAMICRO-003'));
  assert.ok(trans.resolvedFindings.includes('VF-DNAMICRO-004'));
  assert.ok(trans.resolvedFindings.includes('VF-DNAMICRO-005'));
  assert.ok(trans.resolvedFindings.includes('VF-DNAMICRO-006'));
  assert.ok(trans.resolvedFindings.includes('VF-DNAMICRO-007'));
  assert.ok(trans.resolvedFindings.includes('VF-DNAMICRO-008'));

  const artifactPatch = synthesizeDnaMicroarrayArtifactPatch(vulnerableCode);
  assert.equal(artifactPatch.patchType, 'dna_microarray_hardening');

  const patchRes = synthesizeDnaMicroarrayPatch(vulnerableCode);
  assert.ok(patchRes.unifiedDiff.includes('dna_microarray_order.json'));

  const injected = synthesizeAndInjectPatch({
    sourceCode: vulnerableCode,
    filename: 'dna_microarray_order.json'
  });
  assert.equal(injected.applied, true);
  assert.ok(injected.findingsResolved.length > 0);
});

// --- 6. Mock Harness & Attack Simulation ---

test('DNA Microarray Biosecurity Gate: Mock harness blocks attacks and tracks telemetry', () => {
  const harness = new MockDnaMicroarrayHarness();

  const attackSim = runDnaMicroarrayAttackSimulation(harness, {
    enforceSelectAgentScreening: false,
    minScreeningWindowBp: 100,
    maxEvalueThreshold: 0.1,
    watermark_signature_present: false,
    kyc_verified: false,
    split_gene_coverage_pct: 35.0,
    spot_density_pct: 95.0,
    fluorophore_crosstalk_pct: 5.5,
    codon_scrambling_detected: true,
    stale_nonce_detected: true,
    fail_open_on_timeout: true
  });

  assert.equal(attackSim.blocked, true);
  assert.ok(attackSim.logs.length > 0);
  assert.ok(attackSim.vectorsDetected.length >= 8);

  const state = harness.getState();
  assert.ok(state.blockedAttacksCount > 0);
  assert.ok(state.detectedVectors.includes('VF-DNAMICRO-001'));
  assert.ok(state.detectedVectors.includes('VF-DNAMICRO-002'));
  assert.ok(state.detectedVectors.includes('VF-DNAMICRO-003'));
  assert.ok(state.detectedVectors.includes('VF-DNAMICRO-004'));
  assert.ok(state.detectedVectors.includes('VF-DNAMICRO-005'));
  assert.ok(state.detectedVectors.includes('VF-DNAMICRO-006'));
  assert.ok(state.detectedVectors.includes('VF-DNAMICRO-007'));
  assert.ok(state.detectedVectors.includes('VF-DNAMICRO-008'));
});

// --- 7. Dual-Phase Canary Verification ---

test('DNA Microarray Biosecurity Gate: Dual-phase canary verifies attack containment', async () => {
  const vulnerableContent = `
{
  "enforceSelectAgentScreening": false,
  "minScreeningWindowBp": 100,
  "maxEvalueThreshold": 0.1,
  "enforceDigitalWatermarking": false,
  "watermark_signature_present": false,
  "enforceInstitutionalKyc": false,
  "kyc_verified": false,
  "enforceMultiFragmentAssemblyCheck": false,
  "split_gene_coverage_pct": 30.0,
  "enforceSpotDensityLimits": false,
  "spot_density_pct": 95.0,
  "fluorophore_crosstalk_pct": 5.0,
  "enforceAminoAcidHomologyScreening": false,
  "codon_scrambling_detected": true,
  "enforceFreshSynthesisNonces": false,
  "stale_nonce_detected": true,
  "enforceFailClosedSynthesisAbort": false,
  "fail_open_on_timeout": true
}
  `;

  const patchedContent = `
{
  "enforceSelectAgentScreening": true,
  "minScreeningWindowBp": 200,
  "maxEvalueThreshold": 1e-10,
  "enforceDigitalWatermarking": true,
  "watermark_signature_present": true,
  "enforceInstitutionalKyc": true,
  "kyc_verified": true,
  "enforceMultiFragmentAssemblyCheck": true,
  "split_gene_coverage_pct": 10.0,
  "enforceSpotDensityLimits": true,
  "spot_density_pct": 85.0,
  "fluorophore_crosstalk_pct": 2.0,
  "enforceAminoAcidHomologyScreening": true,
  "codon_scrambling_detected": false,
  "enforceFreshSynthesisNonces": true,
  "stale_nonce_detected": false,
  "enforceFailClosedSynthesisAbort": true,
  "fail_open_on_timeout": false
}
  `;

  const canaryReport = await executeDnaMicroarrayCanaryVerification(vulnerableContent, patchedContent);
  assert.equal(canaryReport.status, 'VERIFIED_SAFE');
  assert.equal(canaryReport.attackBlocked, true);
  assert.equal(canaryReport.benignPreserved, true);
});

// --- 8. MCP Server Integration ---

test('MCP Server: Registers vulnforge_audit_dna_microarray as 63rd Core Tool & executes tool call', async () => {
  const server = createVulnForgeServer();
  assert.ok(server);

  // Test tool listing
  const listHandler = server._requestHandlers?.get(ListToolsRequestSchema.shape.method.value);
  assert.ok(listHandler, 'ListTools handler must exist');
  const toolsResult = await listHandler({ method: 'tools/list', params: {} });
  const dnaTool = toolsResult.tools.find((t) => t.name === 'vulnforge_audit_dna_microarray');
  assert.ok(dnaTool, 'vulnforge_audit_dna_microarray must be registered in MCP tools list');
  assert.ok(dnaTool.description.includes('VF-DNAMICRO-001'));
  assert.equal(dnaTool.inputSchema.required.includes('content'), true);

  // Test tool execution
  const callHandler = server._requestHandlers?.get(CallToolRequestSchema.shape.method.value);
  assert.ok(callHandler, 'CallTool handler must exist');

  const callResult = await callHandler({
    method: 'tools/call',
    params: {
      name: 'vulnforge_audit_dna_microarray',
      arguments: {
        content: JSON.stringify(DEFAULT_DNA_MICROARRAY_BIOSECURITY_POLICY),
        filePath: 'dna_microarray_order.json'
      }
    }
  });
  assert.ok(callResult);
  assert.ok(!callResult.isError);
  const parsed = JSON.parse(callResult.content[0].text);
  assert.equal(parsed.passed, true);
  assert.equal(parsed.summary.score, 100);
});

// --- 9. Full Scan MCP Integration ---

test('MCP Server: vulnforge_full_scan includes DNA Microarray Biosecurity layer', async () => {
  const server = createVulnForgeServer();
  assert.ok(server);

  const callHandler = server._requestHandlers?.get(CallToolRequestSchema.shape.method.value);
  assert.ok(callHandler);

  const fullScanResult = await callHandler({
    method: 'tools/call',
    params: {
      name: 'vulnforge_full_scan',
      arguments: {
        dnaMicroarrayCode: JSON.stringify({
          order_id: 'FULLSCAN-ORD-01',
          screen_window_bp: 100,
          homology_e_value: 0.05,
          watermark_signature_present: false,
          kyc_verified: false,
          split_gene_coverage_pct: 25.0,
          spot_density_pct: 95.0,
          codon_scrambling_detected: true,
          stale_nonce_detected: true,
          fail_open_on_timeout: true
        }),
        dnaMicroarrayPath: 'dna_microarray_order.json',
        verifyInSandbox: false
      }
    }
  });

  assert.ok(fullScanResult);
  assert.ok(!fullScanResult.isError);
  const parsed = JSON.parse(fullScanResult.content[0].text);
  assert.ok(parsed.dnaMicroarrayReport);
  assert.equal(parsed.dnaMicroarrayReport.passed, false);
  assert.ok(parsed.dnaMicroarrayReport.summary.findingsCount >= 8);
  assert.ok(parsed.totalFindings >= 8);
});