@resolveio/server-lib 22.3.140 → 22.3.142

package/tests/aicoder-runner-v6.test.ts

@@ -0,0 +1,268 @@
+import * as assert from 'node:assert/strict';
+import {
+	buildResolveIOAICoderV6DiagnoseFirstPrompt,
+	decideResolveIOAICoderV6Continuation,
+	fingerprintResolveIOAICoderV6Blocker,
+	initializeResolveIOAICoderV6State,
+	recordResolveIOAICoderV6Step
+} from '../src/util/aicoder-runner-v6';
+
+const initialized = initializeResolveIOAICoderV6State({
+	runKind: 'initial_builder',
+	jobId: 'job-1',
+	appId: 'app-1',
+	title: 'Build crypto dashboard',
+	description: 'Create a complete crypto trading dashboard.',
+	branchName: 'ai/crypto-dashboard',
+	now: '2026-06-07T12:00:00.000Z'
+});
+
+assert.equal(initialized.aiCoderRunnerVersion, 'v6');
+assert.equal(initialized.aiCoderV6SupervisorState.runKind, 'initial_builder');
+assert.equal(initialized.aiCoderV6SupervisorState.activeLane, 'plan');
+assert.equal(initialized.aiCoderV6LaneMemory.build.threadKey, 'aicoder:initial_builder:job-1:build');
+assert.equal(initialized.aiCoderV6Budget.maxRepeatedNoProgress, 2);
+assert.equal(initialized.aiCoderV6WorkflowMemory.journeyContractPath, 'docs/APP_JOURNEY_CONTRACT.md');
+assert.deepEqual(initialized.aiCoderV6RecoveryDispatchHistory, []);
+assert.equal(initialized.aiCoderV6RecoveryDirective, undefined);
+
+const withBuildFailure = recordResolveIOAICoderV6Step(initialized, {
+	lane: 'build',
+	stepType: 'build',
+	outcome: 'needs_repair',
+	model: 'gpt-5.3-codex',
+	threadKey: 'job-1:build',
+	promptVersion: 'abc123',
+	promptTokenEstimate: 1200,
+	inputTokens: 1000,
+	cachedInputTokens: 200,
+	outputTokens: 300,
+	summary: 'Angular build failed.',
+	blocker: 'TS2304 line 42 cannot find name InvoiceModel',
+	changedFiles: ['angular/app/dashboard/hub/dashboard-hub.component.ts'],
+	artifactPaths: ['.dashboard-output/build-client.log'],
+	now: '2026-06-07T12:01:00.000Z'
+});
+
+assert.equal(withBuildFailure.aiCoderV6SupervisorState.activeLane, 'build');
+assert.equal(withBuildFailure.aiCoderV6SupervisorState.activeStep, 'build');
+assert.equal(withBuildFailure.aiCoderV6LaneMemory.build.latestPromptVersion, 'abc123');
+assert.equal(withBuildFailure.aiCoderV6Budget.totalInputTokens, 1000);
+assert.equal(withBuildFailure.aiCoderV6Budget.totalCachedInputTokens, 200);
+assert.equal(withBuildFailure.aiCoderV6Budget.totalOutputTokens, 300);
+assert.equal(withBuildFailure.aiCoderV6StepHistory[0].blockerFingerprint, fingerprintResolveIOAICoderV6Blocker('TS2304 line 99 cannot find name InvoiceModel'));
+assert.equal(withBuildFailure.aiCoderV6RecoveryPlan?.recoveryClass, 'compile_repair');
+assert.equal(withBuildFailure.aiCoderV6RecoveryCheckpoint?.recoveryClass, 'compile_repair');
+assert.equal(withBuildFailure.aiCoderV6RecoveryAction?.checkpointId, withBuildFailure.aiCoderV6RecoveryCheckpoint?.checkpointId);
+const buildFailureDecision = decideResolveIOAICoderV6Continuation(withBuildFailure);
+assert.equal(buildFailureDecision.action, 'infra_retry');
+assert.equal(buildFailureDecision.reason, 'aicoder_v6_compile_repair_required');
+assert.equal(buildFailureDecision.recoveryPlan.recoveryClass, 'compile_repair');
+assert.equal(buildFailureDecision.recoveryPlan.productRepairAllowed, false);
+assert.ok(buildFailureDecision.recoveryPlan.requiredEvidence.includes('compile log artifact'));
+assert.equal(buildFailureDecision.recoveryCheckpoint.recoveryClass, 'compile_repair');
+assert.equal(buildFailureDecision.recoveryCheckpoint.productRepairAllowed, false);
+
+const withWorkflowQa = recordResolveIOAICoderV6Step(initialized, {
+	lane: 'qa',
+	stepType: 'workflow_qa',
+	outcome: 'pass',
+	primaryWorkflowId: 'north-star',
+	activeWorkflowStep: 'save-result',
+	workflowQaRows: [{
+		index: 1,
+		workflowId: 'north-star',
+		stepId: 'save-result',
+		route: '/dashboard/hub',
+		action: 'Save recommendation',
+		assertion: 'Saved result appears in the recommendations table.',
+		expectedState: 'Recommendation saved',
+		status: 'pass',
+		artifactPaths: ['.build-output/workflow-save-result.png']
+	}],
+	artifactPaths: ['.build-output/workflow-save-result.png'],
+	summary: 'North-star workflow QA passed.'
+});
+
+assert.equal(withWorkflowQa.aiCoderV6WorkflowMemory.primaryWorkflowId, 'north-star');
+assert.equal(withWorkflowQa.aiCoderV6WorkflowMemory.activeWorkflowStep, 'save-result');
+assert.equal(withWorkflowQa.aiCoderV6WorkflowMemory.completedWorkflowSteps.includes('save-result'), true);
+assert.equal(withWorkflowQa.aiCoderV6WorkflowMemory.workflowQaRows[0].route, '/dashboard/hub');
+assert.equal(withWorkflowQa.aiCoderV6WorkflowMemory.businessProofArtifacts.includes('.build-output/workflow-save-result.png'), true);
+
+let repeated = withBuildFailure;
+for (let index = 0; index < 3; index += 1) {
+	repeated = recordResolveIOAICoderV6Step(repeated, {
+		lane: 'build',
+		stepType: 'build',
+		outcome: 'needs_repair',
+		summary: 'Angular build failed.',
+		blocker: 'TS2304 line 77 cannot find name InvoiceModel',
+		now: `2026-06-07T12:0${index + 2}:00.000Z`
+	});
+}
+
+const repeatedDecision = decideResolveIOAICoderV6Continuation(repeated);
+assert.equal(repeatedDecision.action, 'park');
+assert.equal(repeatedDecision.reason, 'aicoder_v6_repeated_no_progress');
+assert.equal(repeatedDecision.recoveryPlan.recoveryClass, 'blocked_until_new_evidence');
+assert.equal(repeatedDecision.recoveryPlan.allowedAction, 'collect_new_evidence_only');
+assert.equal(repeatedDecision.recoveryCheckpoint.status, 'parked');
+assert.equal(repeatedDecision.recoveryCheckpoint.allowedAction, 'collect_new_evidence_only');
+assert.equal(repeatedDecision.recoveryEvidenceProbe.evidenceOnly, true);
+assert.equal(repeatedDecision.recoveryEvidenceProbe.productRepairAllowed, false);
+assert.ok(repeatedDecision.recoveryEvidenceProbe.steps.some((step) => step.kind === 'rerun_same_gate'));
+assert.equal(repeatedDecision.recoveryAction.mode, 'collect_evidence');
+assert.equal(repeatedDecision.recoveryAction.retryPolicy.requireNewEvidence, true);
+assert.equal(repeatedDecision.recoveryAction.productRepairAllowed, false);
+assert.equal(repeated.aiCoderV6RecoveryPlan?.recoveryClass, 'blocked_until_new_evidence');
+assert.equal(repeated.aiCoderV6RecoveryCheckpoint?.status, 'parked');
+assert.equal(repeated.aiCoderV6RecoveryEvidenceProbe?.checkpointId, repeated.aiCoderV6RecoveryCheckpoint?.checkpointId);
+
+const newEvidenceRetry = recordResolveIOAICoderV6Step(withBuildFailure, {
+	lane: 'build',
+	stepType: 'build',
+	outcome: 'needs_repair',
+	failureClass: 'compile',
+	summary: 'Angular build failed with the same root blocker after a targeted change.',
+	blocker: 'TS2304 line 88 cannot find name InvoiceModel',
+	evidenceHash: 'compile-log-after-import-fix',
+	changedFiles: ['angular/app/dashboard/hub/dashboard-hub.component.ts'],
+	artifactPaths: ['.dashboard-output/build-client-after-import.log']
+});
+assert.equal(newEvidenceRetry.aiCoderV6Budget.loopCount, 1);
+const newEvidenceDecision = decideResolveIOAICoderV6Continuation(newEvidenceRetry);
+assert.equal(newEvidenceDecision.action, 'infra_retry');
+assert.equal(newEvidenceDecision.recoveryPlan.recoveryClass, 'compile_repair');
+assert.equal(newEvidenceDecision.recoveryPlan.productRepairAllowed, false);
+assert.ok(newEvidenceDecision.recoveryPlan.loopResetEvidence.some((entry) => /same check now passes|new infra\/compile blocker hash/.test(entry)));
+
+const infraFailure = recordResolveIOAICoderV6Step(initialized, {
+	lane: 'qa',
+	stepType: 'workflow_qa',
+	outcome: 'needs_repair',
+	failureClass: 'infra',
+	summary: 'Puppeteer could not launch Chrome.',
+	blocker: 'Puppeteer could not launch Chrome from the configured executable path.'
+});
+const infraDecision = decideResolveIOAICoderV6Continuation(infraFailure);
+assert.equal(infraDecision.action, 'infra_retry');
+assert.equal(infraDecision.nextLane, 'qa');
+assert.equal(infraDecision.reason, 'aicoder_v6_infra_retry');
+assert.equal(infraDecision.recoveryPlan.recoveryClass, 'infra_repair');
+assert.equal(infraDecision.recoveryPlan.expensiveModelAllowed, false);
+assert.ok(infraDecision.recoveryPlan.forbiddenActions.some((action) => /product-code model repair/.test(action)));
+
+const journeyFailure = recordResolveIOAICoderV6Step(initialized, {
+	lane: 'plan',
+	stepType: 'journey_validation',
+	outcome: 'needs_repair',
+	summary: 'Journey contract is missing first/next/last steps.',
+	blocker: 'docs/APP_JOURNEY_CONTRACT.md journey_contract.north_star_workflow has fewer than 3 ordered steps.'
+});
+const journeyDecision = decideResolveIOAICoderV6Continuation(journeyFailure);
+assert.equal(journeyDecision.action, 'retry_same_step');
+assert.equal(journeyDecision.nextLane, 'plan');
+assert.equal(journeyDecision.nextStep, 'journey_contract');
+assert.equal(journeyDecision.reason, 'aicoder_v6_journey_contract_repair_required');
+assert.equal(journeyDecision.recoveryPlan.recoveryClass, 'journey_contract_repair');
+assert.equal(journeyDecision.recoveryPlan.productRepairAllowed, false);
+assert.ok(journeyDecision.recoveryPlan.forbiddenActions.some((action) => /empty routes/.test(action)));
+
+const releaseFailure = recordResolveIOAICoderV6Step(initialized, {
+	lane: 'publish',
+	stepType: 'test_deploy',
+	outcome: 'needs_repair',
+	summary: 'Test deploy failed after workflow QA passed.',
+	blocker: 'CloudFront invalidation failed during test deploy.'
+});
+const releaseDecision = decideResolveIOAICoderV6Continuation(releaseFailure);
+assert.equal(releaseDecision.action, 'retry_same_step');
+assert.equal(releaseDecision.nextLane, 'publish');
+assert.equal(releaseDecision.nextStep, 'test_deploy');
+assert.equal(releaseDecision.reason, 'aicoder_v6_release_repair_required');
+assert.equal(releaseDecision.recoveryPlan.recoveryClass, 'release_repair');
+assert.equal(releaseDecision.recoveryPlan.expensiveModelAllowed, false);
+assert.ok(releaseDecision.recoveryPlan.forbiddenActions.some((action) => /scorecard only/.test(action)));
+
+let pingPong = initialized;
+for (const blocker of ['Workflow save button is disabled', 'Workflow save button is enabled but does not persist', 'Workflow save button is disabled', 'Workflow save button is enabled but does not persist']) {
+	pingPong = recordResolveIOAICoderV6Step(pingPong, {
+		lane: 'qa',
+		stepType: 'workflow_qa',
+		outcome: 'needs_repair',
+		failureClass: 'business',
+		summary: blocker,
+		blocker,
+		evidenceHash: blocker
+	});
+}
+const pingPongDecision = decideResolveIOAICoderV6Continuation(pingPong);
+assert.equal(pingPongDecision.action, 'park');
+assert.equal(pingPongDecision.reason, 'aicoder_v6_ping_pong_no_progress');
+assert.equal(pingPongDecision.recoveryPlan.recoveryClass, 'blocked_until_new_evidence');
+assert.ok(pingPongDecision.recoveryPlan.forbiddenActions.some((action) => /alternate between two failed patches/.test(action)));
+
+let terminalReplay = initializeResolveIOAICoderV6State({
+	runKind: 'terminal_helper',
+	jobId: 'terminal-job-1',
+	appId: 'app-1',
+	conversationId: 'conversation-1',
+	title: 'Fix app dashboard save action',
+	description: 'Terminal helper should recover from repeated dashboard save failures.',
+	branchName: 'ai/terminal-dashboard-fix',
+	now: '2026-06-07T12:20:00.000Z'
+});
+for (let index = 0; index < 3; index += 1) {
+	terminalReplay = recordResolveIOAICoderV6Step(terminalReplay, {
+		lane: 'repair',
+		stepType: 'repair',
+		outcome: 'needs_repair',
+		failureClass: 'product_code',
+		summary: 'Dashboard save action throws TypeError.',
+		blocker: 'Dashboard save action throws TypeError cannot read property id.',
+		evidenceHash: 'terminal-save-typeerror',
+		artifactPaths: ['.terminal-output/save-typeerror.log']
+	});
+}
+const terminalReplayDecision = decideResolveIOAICoderV6Continuation(terminalReplay);
+assert.equal(terminalReplayDecision.action, 'park');
+assert.equal(terminalReplayDecision.recoveryPlan.recoveryClass, 'blocked_until_new_evidence');
+assert.equal(terminalReplayDecision.recoveryPlan.allowedAction, 'collect_new_evidence_only');
+assert.ok(terminalReplayDecision.recoveryPlan.loopResetEvidence.some((evidence) => /new artifact path/.test(evidence)));
+assert.equal(terminalReplayDecision.recoveryCheckpoint.status, 'parked');
+assert.equal(terminalReplayDecision.recoveryCheckpoint.recoveryClass, 'blocked_until_new_evidence');
+assert.equal(terminalReplayDecision.recoveryEvidenceProbe.evidenceOnly, true);
+assert.ok(terminalReplayDecision.recoveryEvidenceProbe.acceptanceEvidence.some((evidence) => /new artifact path|changed evidence hash/i.test(evidence)));
+assert.equal(terminalReplayDecision.recoveryAction.mode, 'collect_evidence');
+assert.equal(terminalReplayDecision.recoveryAction.evidenceOnly, true);
+assert.ok(terminalReplayDecision.recoveryAction.successCriteria.some((evidence) => /new artifact path|changed evidence hash/i.test(evidence)));
+
+const prompt = buildResolveIOAICoderV6DiagnoseFirstPrompt({
+	goal: 'Ship a full-featured app update',
+	activeLane: 'repair',
+	activeStep: 'repair',
+	activeBlocker: 'Build failed',
+	journeyContractPath: 'docs/APP_JOURNEY_CONTRACT.md',
+	activeWorkflowStep: 'save-result',
+	changedFiles: ['server/src/methods/invoices.ts'],
+	artifactPaths: ['qa-artifacts/mobile.png']
+});
+
+assert.ok(prompt.some((line) => /Diagnose First/i.test(line)));
+assert.ok(prompt.some((line) => /Active lane: repair/i.test(line)));
+assert.ok(prompt.some((line) => /server\/src\/methods\/invoices\.ts/i.test(line)));
+assert.ok(prompt.some((line) => /Journey contract: docs\/APP_JOURNEY_CONTRACT\.md/i.test(line)));
+
+const budgeted = recordResolveIOAICoderV6Step(initialized, {
+	lane: 'plan',
+	stepType: 'plan',
+	outcome: 'pass',
+	promptTokenEstimate: 9000,
+	summary: 'Large plan prompt.'
+});
+
+assert.equal(decideResolveIOAICoderV6Continuation(budgeted).action, 'budget_stop');
+assert.equal(decideResolveIOAICoderV6Continuation(budgeted).recoveryPlan.recoveryClass, 'manual_handoff');
+
+console.log('aicoder runner v6 tests passed');

package/tests/error-reporter.test.ts

@@ -0,0 +1,145 @@
+import { ResolveIOServer } from '../src/resolveio-server-app';
+import { ErrorReporter } from '../src/util/error-reporter';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+function setServerConfig(overrides: Record<string, any> = {}) {
+	const serverAny = ResolveIOServer as unknown as Record<string, any>;
+	serverAny._serverConfig = Object.assign({
+		CLIENT_NAME: 'TestClient',
+		ROOT_URL: 'https://test.resolveio.com',
+		SERVER_URL: 'https://backend.resolveio.com'
+	}, overrides);
+	serverAny._client = 'test-client';
+}
+
+function setAutoFixManager(manager: any) {
+	const serverAny = ResolveIOServer as unknown as Record<string, any>;
+	serverAny.AutoFixManager = manager;
+}
+
+async function testSuccessfulLocalIngest() {
+	setServerConfig();
+	let payloadSnapshot: any = null;
+	setAutoFixManager({
+		isReady: () => true,
+		ingestErrorReport: async (payload: any) => {
+			payloadSnapshot = payload;
+			return {status: 'queued'};
+		}
+	});
+
+	const result = await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Invoice close failed',
+		context: {foo: 'bar'}
+	});
+
+	assert(result.delivered === true, 'Expected report to be delivered');
+	assert(result.status === 200, 'Expected local status code');
+	assert(result.reason === 'queued', 'Expected ingest status to propagate');
+	assert(payloadSnapshot !== null, 'Expected payload to be ingested');
+	assert(payloadSnapshot.message === 'Invoice close failed', 'Expected message in payload');
+	assert(payloadSnapshot.sourceApp === 'unit-test', 'Expected sourceApp in payload');
+	assert(payloadSnapshot.context.foo === 'bar', 'Expected context payload');
+	assert(typeof payloadSnapshot.fingerprint === 'string' && payloadSnapshot.fingerprint.length > 0, 'Expected fingerprint');
+	assert(payloadSnapshot.reportedAt instanceof Date, 'Expected reportedAt to be a Date');
+}
+
+async function testManagerMissing() {
+	setServerConfig();
+	setAutoFixManager(null);
+
+	const result = await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Should fail without manager'
+	});
+
+	assert(result.delivered === false, 'Expected local manager missing failure');
+	assert(result.reason === 'local-manager-missing', 'Expected local-manager-missing reason');
+}
+
+async function testManagerNotReady() {
+	setServerConfig();
+	setAutoFixManager({
+		isReady: () => false,
+		ingestErrorReport: async () => ({status: 'queued'})
+	});
+
+	const result = await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Should fail when manager not ready'
+	});
+
+	assert(result.delivered === false, 'Expected manager not-ready failure');
+	assert(result.reason === 'local-manager-not-ready', 'Expected local-manager-not-ready reason');
+}
+
+async function testManagerIngestFailure() {
+	setServerConfig();
+	setAutoFixManager({
+		isReady: () => true,
+		ingestErrorReport: async () => {
+			throw new Error('ingest boom');
+		}
+	});
+
+	const result = await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Should fail on ingest error'
+	});
+
+	assert(result.delivered === false, 'Expected local ingest failure');
+	assert(result.reason === 'local-ingest-failed', 'Expected local-ingest-failed reason');
+}
+
+async function testInvalidDateSerializationDoesNotThrow() {
+	setServerConfig();
+	let payloadSnapshot: any = null;
+	setAutoFixManager({
+		isReady: () => true,
+		ingestErrorReport: async (payload: any) => {
+			payloadSnapshot = payload;
+			return {status: 'queued'};
+		}
+	});
+
+	await ErrorReporter.report({
+		sourceApp: 'unit-test',
+		message: 'Invalid date handling',
+		context: {
+			badDate: new Date('not-a-date'),
+			okDate: new Date('2024-01-01T00:00:00.000Z')
+		},
+		reportedAt: new Date('not-a-date')
+	});
+
+	assert(payloadSnapshot !== null, 'Expected payload snapshot for invalid date test');
+	assert(payloadSnapshot.context.badDate === null, 'Expected invalid date to serialize as null');
+	assert(payloadSnapshot.context.okDate === '2024-01-01T00:00:00.000Z', 'Expected valid date to serialize normally');
+	assert(payloadSnapshot.reportedAt instanceof Date, 'Expected fallback reportedAt as Date');
+}
+
+async function run() {
+	try {
+		await testSuccessfulLocalIngest();
+		await testManagerMissing();
+		await testManagerNotReady();
+		await testManagerIngestFailure();
+		await testInvalidDateSerializationDoesNotThrow();
+		console.log('error reporter tests passed');
+	}
+	finally {
+		setAutoFixManager(null);
+	}
+}
+
+run().catch(err => {
+	console.error('error reporter tests failed');
+	console.error(err);
+	process.exit(1);
+});

package/tests/method-publication-generator.test.ts

@@ -0,0 +1,46 @@
+import { execFileSync } from 'child_process';
+
+const script = `
+import importlib.util
+
+spec = importlib.util.spec_from_file_location('generator', 'methodAndPublicationListGenerator.py')
+generator = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(generator)
+
+params, calls = generator.trim_user_specific_publication_params(
+    ['id_current_user: string', 'id_user?: string'],
+    ['id_current_user', 'id_user'],
+    True,
+    'yardsForUser'
+)
+assert params == ['id_user?: string'], params
+assert calls == ['id_user'], calls
+
+params, calls = generator.trim_user_specific_publication_params(
+    ['id_user: string', 'limit?: number'],
+    ['id_user', 'limit'],
+    True,
+    'userNotificationCenter'
+)
+assert params == ['limit?: number'], params
+assert calls == ['limit'], calls
+
+try:
+    generator.trim_user_specific_publication_params(
+        ['id_user?: string'],
+        ['id_user'],
+        True,
+        'yardsForUser'
+    )
+except ValueError as exc:
+    assert 'ambiguous optional id_user' in str(exc), str(exc)
+else:
+    raise AssertionError('Expected ambiguous yardsForUser signature to fail')
+
+print('method publication generator tests passed')
+`;
+
+execFileSync('python3', ['-c', script], {
+	cwd: process.cwd(),
+	stdio: 'inherit'
+});

package/tests/report-builder-linking.test.ts

@@ -0,0 +1,79 @@
+import { applyLinkFieldUnwinds } from '../src/util/report-builder-unwinds';
+
+function assert(condition: boolean, message: string) {
+	if (!condition) {
+		throw new Error(message);
+	}
+}
+
+function countUnwinds(query: any[], path: string) {
+	return query.filter(stage => stage?.$unwind?.path === path).length;
+}
+
+function countLookups(query: any[], as: string) {
+	return query.filter(stage => stage?.$lookup?.as === as).length;
+}
+
+function testAddsMissingUnwindsForLinkedLookupArrayField() {
+	const query: any[] = [];
+	const sizes: string[] = [];
+
+	const lookupAsRaw = 'items.$.wo_details.$.Work-order-dynamics (Items -> Wo Details -> Wo) (Lookup)';
+	const lookupAs = 'items.wo_details.Work-order-dynamics (Items -> Wo Details -> Wo) (Lookup)';
+
+	const fieldFirst = lookupAsRaw + '.$.chemicals.$.id_chemical';
+	const fieldSecond = 'items.$.id_chemical';
+
+	const selectedFields = [
+		{
+			fieldPath: fieldFirst,
+			lookup_collection: 'work-order-dynamics',
+			lookup_local_key: 'items.wo_details.id_wo',
+			lookup_foreign_key: '_id',
+			lookup_as: lookupAsRaw
+		},
+		{
+			fieldPath: fieldSecond,
+			lookup_collection: '',
+			lookup_local_key: '',
+			lookup_foreign_key: '',
+			lookup_as: ''
+		}
+	];
+
+	applyLinkFieldUnwinds({
+		query,
+		sizes,
+		fieldsLink: [{field_first: fieldFirst, field_second: fieldSecond, id: 'link_1'}],
+		selectedFields,
+		filterArrayFields: [],
+		groupsRow: []
+	});
+
+	assert(countLookups(query, lookupAs) === 1, 'Expected lookup stage for linked lookup field');
+	assert(countUnwinds(query, '$items') === 1, 'Expected unwind for items');
+	assert(countUnwinds(query, '$items.wo_details') === 1, 'Expected unwind for items.wo_details');
+	assert(countUnwinds(query, '$' + lookupAs) === 1, 'Expected unwind for lookup results');
+	assert(countUnwinds(query, '$' + lookupAs + '.chemicals') === 1, 'Expected unwind for lookup chemicals array');
+
+	const originalLength = query.length;
+
+	applyLinkFieldUnwinds({
+		query,
+		sizes,
+		fieldsLink: [{field_first: fieldFirst, field_second: fieldSecond, id: 'link_1'}],
+		selectedFields,
+		filterArrayFields: [],
+		groupsRow: []
+	});
+
+	assert(query.length === originalLength, 'Expected second call to be idempotent');
+}
+
+function run() {
+	testAddsMissingUnwindsForLinkedLookupArrayField();
+	console.log('report builder linking tests passed');
+}
+
+run();
+