233 lines
18 KiB
TypeScript
233 lines
18 KiB
TypeScript
// @vitest-environment jsdom
|
|
import { act } from 'react';
|
|
import { createRoot } from 'react-dom/client';
|
|
import { afterEach, expect, it, vi } from 'vitest';
|
|
import { DataHub } from '../../src/features/project-import/DataHub';
|
|
import { withReferenceReadiness } from '../../src/features/project-import/datahub-processing-readiness';
|
|
|
|
const api = vi.hoisted(() => ({ health: vi.fn(), getMitreCatalog: vi.fn(), listProjects: vi.fn(),
|
|
listProjectImportFiles: vi.fn(), listProjectAssessmentHistory: vi.fn(), listProjectGpoBackupStatus: vi.fn(),
|
|
getTimeslotResultMetrics: vi.fn(), queryUnifiedResultFacets: vi.fn(), getReferenceRecognitionStatus: vi.fn(),
|
|
recognizeReferences: vi.fn(), refreshMitreCatalog: vi.fn(), listProjectAssessments: vi.fn(), loadAssessmentModel: vi.fn() }));
|
|
vi.mock('../../src/api/assessor-api-client', () => ({ AssessorApiClient: class {
|
|
health = api.health; getMitreCatalog = api.getMitreCatalog; listProjects = api.listProjects;
|
|
listProjectImportFiles = api.listProjectImportFiles; listProjectAssessmentHistory = api.listProjectAssessmentHistory;
|
|
listProjectGpoBackupStatus = api.listProjectGpoBackupStatus; getTimeslotResultMetrics = api.getTimeslotResultMetrics;
|
|
queryUnifiedResultFacets = api.queryUnifiedResultFacets; getReferenceRecognitionStatus = api.getReferenceRecognitionStatus;
|
|
recognizeReferences = api.recognizeReferences;
|
|
refreshMitreCatalog = api.refreshMitreCatalog;
|
|
listProjectAssessments = api.listProjectAssessments; loadAssessmentModel = api.loadAssessmentModel;
|
|
} }));
|
|
vi.mock('../../src/features/project-import/MicrosoftBaselineLibrary', () => ({ MicrosoftBaselineLibrary: () => null }));
|
|
vi.mock('../../src/features/file-import/FileImport', () => ({ FileImport: () => null }));
|
|
vi.mock('../../src/features/project-import/GpoFolderImport', () => ({ GpoFolderImport: () => null }));
|
|
|
|
afterEach(() => { vi.resetAllMocks(); vi.unstubAllGlobals(); document.body.replaceChildren(); });
|
|
|
|
const projectId = 'synthetic-reference-client';
|
|
const referenceStatus = (pendingScans: number, indexedScans = 2) => ({ totalScans: 2, indexedScans, pendingScans,
|
|
catalogs: [{ framework: 'mitre-attack', version: '19.2', sha256: 'synthetic-hash' }] });
|
|
function fixture() {
|
|
vi.stubGlobal('IS_REACT_ACT_ENVIRONMENT', true);
|
|
const date = '2026-01-01T00:00:00Z';
|
|
api.health.mockResolvedValue({ status: 'ok', repositoryRevision: 801 });
|
|
api.getMitreCatalog.mockResolvedValue({ catalog: { version: '19.2', tacticOrder: ['Execution'],
|
|
techniques: [{ id: 'T1059', name: 'Synthetic', tactics: ['Execution'] }], entities: [] } });
|
|
api.listProjects.mockResolvedValue([{ id: projectId, name: 'Synthetic client', attributes: {}, createdAt: date, updatedAt: date }]);
|
|
api.listProjectImportFiles.mockResolvedValue([]);
|
|
api.listProjectGpoBackupStatus.mockResolvedValue({ records: [] });
|
|
api.listProjectAssessmentHistory.mockResolvedValue({ version: 1, projectId,
|
|
assessments: ['first', 'second'].map(id => ({ id, projectId, name: `Synthetic ${id}`, createdAt: date, updatedAt: date, effectiveAt: date })),
|
|
scanRuns: ['first', 'second'].map(id => ({ id: `${id}-run`, assessmentId: id, sequence: 1, label: 'Synthetic scan', importedAt: date,
|
|
tool: { id: 'synthetic', name: 'Synthetic scanner' } })) });
|
|
api.getTimeslotResultMetrics.mockResolvedValue({ all: 2, deviation: 1, passed: 1, notApplicable: 0, notRun: 0, error: 0 });
|
|
api.queryUnifiedResultFacets.mockResolvedValue({ total: 2, facets: [] });
|
|
api.getReferenceRecognitionStatus.mockResolvedValue(referenceStatus(2, 0));
|
|
api.recognizeReferences.mockImplementation(async () => {
|
|
api.getReferenceRecognitionStatus.mockResolvedValue(referenceStatus(0));
|
|
return { processedScans: 2, unchangedScans: 0, references: 4 };
|
|
});
|
|
}
|
|
|
|
it.each([0, 2])('warns before client selection for pending references (indexed=%i), and clears the warning after Manage recognition', async indexedScans => {
|
|
fixture();
|
|
api.getReferenceRecognitionStatus.mockResolvedValue(referenceStatus(2, indexedScans));
|
|
const changed = vi.fn();
|
|
const host = document.createElement('div'); document.body.append(host); const root = createRoot(host);
|
|
try {
|
|
await act(async () => root.render(<DataHub backendStatus="connected" onProjectSelected={() => undefined} onProjectDataChanged={changed}/>));
|
|
expect(host.querySelector('.datahub-tenant-processing-dot')?.getAttribute('data-status')).toBe('update');
|
|
expect(host.querySelector('.datahub-tenant-show')?.getAttribute('data-status')).toBe('update');
|
|
expect(host.querySelector('.datahub-tenant-show')?.getAttribute('title')).toContain('2 scans require reference recognition');
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.datahub-tenant-show')!.click());
|
|
const panel = host.querySelector('.tenant-detail-navigation .reference-recognition');
|
|
expect(panel?.nextElementSibling?.classList.contains('tenant-timeslots')).toBe(true);
|
|
expect(host.querySelector('.tenant-information-sheet .reference-recognition')).toBeNull();
|
|
expect(panel?.textContent).toContain('Catalog references');
|
|
const disclosure = panel!.querySelector('details')!;
|
|
expect(disclosure.open).toBe(true);
|
|
expect(disclosure.querySelector('summary .reference-recognition-dot')?.getAttribute('data-state')).toBe('attention');
|
|
await act(async () => disclosure.querySelector('summary')!.click());
|
|
expect(disclosure.open).toBe(false);
|
|
await act(async () => disclosure.querySelector('summary')!.click());
|
|
expect(disclosure.open).toBe(true);
|
|
expect(panel?.querySelector('[role="status"]')?.textContent).toContain('Please update');
|
|
expect(panel?.textContent).not.toContain('Recognize ATT&CK and D3FEND references in');
|
|
const button = panel!.querySelector<HTMLButtonElement>('button')!;
|
|
expect(button.textContent).toBe('Update references');
|
|
expect(button.disabled).toBe(false);
|
|
expect(button.dataset.attention).toBe('true');
|
|
expect(button.classList.contains('primary')).toBe(true);
|
|
await act(async () => button.click());
|
|
expect(api.recognizeReferences).toHaveBeenCalledExactlyOnceWith(projectId);
|
|
expect(changed).toHaveBeenCalledExactlyOnceWith(projectId);
|
|
expect(panel?.querySelector('[role="status"]')?.textContent).toContain('Update successful');
|
|
expect(panel?.querySelector('[role="status"]')?.textContent).toContain('No action needed.');
|
|
expect(button.dataset.attention).toBe('false');
|
|
expect(disclosure.open).toBe(true);
|
|
expect(disclosure.querySelector('summary .reference-recognition-dot')?.getAttribute('data-state')).toBe('ready');
|
|
expect(disclosure.querySelector('[role="status"] .reference-recognition-dot')?.getAttribute('data-state')).toBe('ready');
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.tenant-edit-client')!.click());
|
|
expect(host.querySelector('.tenant-detail-navigation .reference-recognition')).toBe(panel);
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.tenant-back')!.click());
|
|
expect(host.querySelector('.datahub-tenant-processing-dot')?.getAttribute('data-status')).toBe('ready');
|
|
expect(host.querySelector('.datahub-tenant-show')).toBeNull();
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.datahub-tenant-select')!.click());
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.datahub-tenant-show')!.click());
|
|
expect(host.querySelector('.reference-recognition [role="status"]')?.textContent).toBe('Up to dateNo action needed.');
|
|
expect(host.querySelector('.reference-recognition-versions')?.textContent).toContain('ATT&CK 19.2');
|
|
const currentDisclosure = host.querySelector<HTMLDetailsElement>('.reference-recognition-disclosure')!;
|
|
expect(currentDisclosure.open).toBe(false);
|
|
expect(currentDisclosure.querySelector('summary .reference-recognition-dot')?.getAttribute('data-state')).toBe('ready');
|
|
expect(host.querySelector('.reference-recognition-versions')?.closest('details')).toBeNull();
|
|
await act(async () => currentDisclosure.querySelector('summary')!.click());
|
|
expect(currentDisclosure.open).toBe(true);
|
|
expect(currentDisclosure.querySelector('[role="status"] .reference-recognition-dot')?.getAttribute('data-state')).toBe('ready');
|
|
} finally { await act(async () => root.unmount()); }
|
|
});
|
|
|
|
it('keeps a recognition failure red on return and allows a successful retry', async () => {
|
|
fixture();
|
|
api.recognizeReferences.mockRejectedValueOnce(new Error('Synthetic recognition failure'));
|
|
const host = document.createElement('div'); document.body.append(host); const root = createRoot(host);
|
|
try {
|
|
await act(async () => root.render(<DataHub backendStatus="connected" onProjectSelected={() => undefined}/>));
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.datahub-tenant-show')!.click());
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.reference-recognition button')!.click());
|
|
expect(host.querySelector('.reference-recognition [role="alert"]')?.textContent).toContain('Synthetic recognition failure');
|
|
expect(host.querySelector<HTMLDetailsElement>('.reference-recognition-disclosure')!.open).toBe(true);
|
|
expect(host.querySelector('summary .reference-recognition-dot')?.getAttribute('data-state')).toBe('attention');
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.tenant-back')!.click());
|
|
expect(host.querySelector('.datahub-tenant-processing-dot')?.getAttribute('data-status')).toBe('error');
|
|
expect(host.querySelector('.datahub-tenant-show')?.getAttribute('data-status')).toBe('error');
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.datahub-tenant-show')!.click());
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.reference-recognition button')!.click());
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.tenant-back')!.click());
|
|
expect(host.querySelector('.datahub-tenant-processing-dot')?.getAttribute('data-status')).toBe('ready');
|
|
} finally { await act(async () => root.unmount()); }
|
|
});
|
|
|
|
it('does not let a slow overview status overwrite successful recognition in the client panel', async () => {
|
|
fixture();
|
|
let resolveOld!: (status: ReturnType<typeof referenceStatus>) => void;
|
|
api.getReferenceRecognitionStatus.mockImplementationOnce(() => new Promise(resolve => { resolveOld = resolve; }));
|
|
const host = document.createElement('div'); document.body.append(host); const root = createRoot(host);
|
|
try {
|
|
await act(async () => root.render(<DataHub backendStatus="connected" onProjectSelected={() => undefined}/>));
|
|
expect(host.querySelector('.datahub-tenant-processing-dot')?.getAttribute('data-status')).toBe('checking');
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.datahub-tenant-select')!.click());
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.datahub-tenant-show')!.click());
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.reference-recognition button')!.click());
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.tenant-back')!.click());
|
|
await act(async () => resolveOld(referenceStatus(2, 0)));
|
|
expect(host.querySelector('.datahub-tenant-processing-dot')?.getAttribute('data-status')).toBe('ready');
|
|
} finally { await act(async () => root.unmount()); }
|
|
});
|
|
|
|
it('keeps unavailable status visible and offers a working status retry in Manage', async () => {
|
|
fixture();
|
|
api.getReferenceRecognitionStatus.mockRejectedValueOnce(new Error('Synthetic unavailable')).mockRejectedValueOnce(new Error('Synthetic unavailable'));
|
|
const host = document.createElement('div'); document.body.append(host); const root = createRoot(host);
|
|
try {
|
|
await act(async () => root.render(<DataHub backendStatus="connected" onProjectSelected={() => undefined}/>));
|
|
expect(host.querySelector('.datahub-tenant-show')?.getAttribute('data-status')).toBe('review');
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.datahub-tenant-show')!.click());
|
|
const retry = [...host.querySelectorAll<HTMLButtonElement>('.reference-recognition button')].find(button => button.textContent === 'Retry status')!;
|
|
expect(host.querySelector<HTMLDetailsElement>('.reference-recognition-disclosure')!.open).toBe(true);
|
|
expect(host.querySelector('summary .reference-recognition-dot')?.getAttribute('data-state')).toBe('attention');
|
|
await act(async () => retry.click());
|
|
expect(host.querySelector<HTMLButtonElement>('.reference-recognition button')!.disabled).toBe(false);
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.tenant-back')!.click());
|
|
expect(host.querySelector('.datahub-tenant-show')?.getAttribute('data-status')).toBe('update');
|
|
} finally { await act(async () => root.unmount()); }
|
|
});
|
|
|
|
it('refreshes reference warnings after a catalog update and a changed import', async () => {
|
|
fixture();
|
|
api.getReferenceRecognitionStatus.mockResolvedValue(referenceStatus(0));
|
|
api.refreshMitreCatalog.mockImplementation(async () => {
|
|
api.getReferenceRecognitionStatus.mockResolvedValue(referenceStatus(2));
|
|
return { updated: true, catalog: { version: '19.3', tacticOrder: ['Execution'],
|
|
techniques: [{ id: 'T1059', name: 'Synthetic', tactics: ['Execution'] }], entities: [] } };
|
|
});
|
|
const host = document.createElement('div'); document.body.append(host); const root = createRoot(host);
|
|
try {
|
|
await act(async () => root.render(<DataHub backendStatus="connected" onProjectSelected={() => undefined}/>));
|
|
expect(host.querySelector('.datahub-tenant-show')).toBeNull();
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.mitre-library .datahub-maintenance-action')!.click());
|
|
expect(host.querySelector('.datahub-tenant-show')?.getAttribute('data-status')).toBe('update');
|
|
api.getReferenceRecognitionStatus.mockResolvedValue(referenceStatus(0));
|
|
await act(async () => globalThis.dispatchEvent(new Event('assessor:datahub-changed')));
|
|
expect(host.querySelector('.datahub-tenant-processing-dot')?.getAttribute('data-status')).toBe('ready');
|
|
} finally { await act(async () => root.unmount()); }
|
|
});
|
|
|
|
it('preserves scanner and GPO error priority alongside a reference update', () => {
|
|
const result = withReferenceReadiness({ state: 'error', label: 'Synthetic GPO error.' },
|
|
{ state: 'ready', status: { ...referenceStatus(2), catalogs: [] } });
|
|
expect(result.state).toBe('error');
|
|
expect(result.label).toContain('Synthetic GPO error.');
|
|
expect(result.label).toContain('2 scans require reference recognition');
|
|
});
|
|
|
|
it.each(['run', 'file', 'observation'])('names AD and Entra scans explicitly after Manage and timeslot expansion, using retained %s scope', async source => {
|
|
fixture();
|
|
const date = '2026-01-01T00:00:00Z';
|
|
const expected = ['Purple Knight for Active Directory', 'Purple Knight for Entra ID',
|
|
'Purple Knight for Active Directory and Entra ID', 'PurpleKnight'];
|
|
const tool = { id: 'purple-knight', name: 'PurpleKnight' };
|
|
const assessment = { id: 'synthetic-scope-assessment', projectId, name: 'Synthetic timeslot', createdAt: date, updatedAt: date, effectiveAt: date };
|
|
const runs = expected.map((name, index) => ({ id: `scope-${index}`, assessmentId: assessment.id, sequence: index + 1,
|
|
label: 'Untrusted title says Entra ID', importedAt: date, tool: { ...tool, name: source === 'run' ? name : tool.name } }));
|
|
const files = runs.map((run, index) => ({ id: `file-${run.id}`, scanRunId: run.id, fileName: 'untrusted-entra-ad.xlsx',
|
|
format: 'Excel', sizeBytes: 100, importedAt: date, detectedTool: { ...tool, name: source === 'file' ? expected[index] : tool.name },
|
|
detection: { level: 'high', score: 1, reasons: ['synthetic'] }, sourceArtifact: { kind: 'not-retained', reason: 'Synthetic' },
|
|
processedWith: { parserId: 'xlsx', parserVersion: '1.0.0', profileId: tool.id, profileVersion: '1.0.0', mappingVersion: '1.0.0' } }));
|
|
const properties = ['purple_knight.ad.security_posture_score', 'purple_knight.entra.security_posture_score'];
|
|
const observations = source === 'observation' ? [0, 1, 2].flatMap(index => (index === 2 ? properties : [properties[index]])
|
|
.map(property => ({ scanRunId: runs[index].id, importFileId: files[index].id, tool, property, originalValue: 70 }))) : [];
|
|
// Unrelated tool and file facts must never assign Entra scope to the unknown fourth run.
|
|
observations.push({ scanRunId: runs[3].id, importFileId: files[3].id, tool: { id: 'maester', name: 'Maester' }, property: properties[1], originalValue: 70 });
|
|
observations.push({ scanRunId: runs[3].id, importFileId: 'foreign-file', tool, property: properties[1], originalValue: 70 });
|
|
api.listProjectAssessmentHistory.mockResolvedValue({ version: 1, projectId, assessments: [assessment], scanRuns: runs });
|
|
api.listProjectImportFiles.mockResolvedValue(files);
|
|
api.listProjectAssessments.mockResolvedValue([assessment]);
|
|
api.loadAssessmentModel.mockResolvedValue({ scanRuns: runs, importFiles: files, environmentObservations: observations,
|
|
findingOccurrences: runs.map(run => ({ id: `occurrence-${run.id}`, scanRunId: run.id })), findingDefinitions: [], evidence: [], diagnostics: [], reviews: [] });
|
|
const originalRuns = structuredClone(runs);
|
|
const host = document.createElement('div'); document.body.append(host); const root = createRoot(host);
|
|
try {
|
|
await act(async () => root.render(<DataHub backendStatus="connected" onProjectSelected={() => undefined}/>));
|
|
await act(async () => host.querySelector<HTMLButtonElement>('.datahub-tenant-show')!.click());
|
|
const timeslot = host.querySelector<HTMLDetailsElement>('.tenant-timeslot')!;
|
|
if (!timeslot.open) await act(async () => timeslot.querySelector('summary')!.click());
|
|
expect(timeslot.open).toBe(true);
|
|
expect([...timeslot.querySelectorAll('.tenant-report-copy b')].map(element => element.textContent)).toEqual(expected);
|
|
for (const name of expected) {
|
|
expect(timeslot.querySelector(`input[aria-label="Select ${name} scan report"]`)).not.toBeNull();
|
|
expect(timeslot.querySelector(`button[aria-label="Delete ${name} scan report"]`)).not.toBeNull();
|
|
}
|
|
expect(runs).toEqual(originalRuns);
|
|
} finally { await act(async () => root.unmount()); }
|
|
});
|