vulnforge-mcp / tests /dna_microarray_audit.test.js

mason-keller

feat: add autonomous biological dna microarray biosecurity attestation gate (v1.58.0)

ff02c4b 9 days ago

18.3 kB

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);
});

	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);
	});