@resolveio/server-lib 22.3.142 → 22.3.143

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

@@ -1,268 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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();
-