@resolveio/server-lib 22.3.61 → 22.3.62

package/tests/ai-runner-contract.test.ts

@@ -0,0 +1,301 @@
+import * as assert from 'node:assert/strict';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+	collectResolveIORunnerEvidenceArtifactPaths,
+	persistResolveIORunnerEvidenceArtifacts
+} from '../src/util/ai-runner-artifacts';
+import {
+	buildResolveIORunnerQaAuthBootstrapScript
+} from '../src/util/ai-runner-qa-auth';
+import {
+	buildResolveIORunnerBugfixComparisonQaScript,
+	buildResolveIORunnerQaEnvScript,
+	buildResolveIORunnerLocalQaScript,
+	buildResolveIORunnerLocalQaStopperScript
+} from '../src/util/ai-runner-qa-tools';
+import {
+	RunnerProcessJanitor
+} from '../src/util/runner-process-janitor';
+import {
+	buildResolveIORunnerContract,
+	buildResolveIORunnerPromptBundle,
+	buildResolveIORunnerQaCoverageChecklist,
+	buildResolveIORunnerRepairPlans,
+	classifyResolveIORunnerBlocker,
+	decideResolveIORunnerRepairContinuation,
+	findRepeatedResolveIORunnerBlockers,
+	normalizeResolveIORunnerBlocker
+} from '../src/util/ai-qa-policy';
+
+const contract = buildResolveIORunnerContract({
+	context: 'support_ticket',
+	includeDevServerRules: true,
+	maxContextBullets: 6
+});
+
+assert.equal(contract.context, 'support_ticket');
+assert.ok(contract.sections.tokenDiscipline.some((line) => /at most 6 bullets/i.test(line)));
+assert.ok(contract.sections.dependencyBootstrap.some((line) => /npm install --force/i.test(line)));
+assert.ok(contract.sections.qaPolicy.some((line) => /screenshot or trace/i.test(line)));
+assert.ok(contract.sections.qaPolicy.some((line) => /qa-auth-bootstrap\.js/i.test(line)));
+assert.ok(contract.sections.qaPolicy.some((line) => /\.resolveio-ai-runner-tools/i.test(line)));
+assert.ok(contract.sections.qaPolicy.some((line) => /QA Coverage Matrix/i.test(line)));
+assert.ok(contract.sections.qaPolicy.some((line) => /invoices, billing, taxes, inventory/i.test(line)));
+assert.ok(contract.rules.some((line) => /same normalized blocker repeats/i.test(line)));
+
+const authBootstrapScript = buildResolveIORunnerQaAuthBootstrapScript({
+	defaultUsername: 'admin',
+	defaultPassword: 'local-secret'
+});
+
+assert.ok(authBootstrapScript.includes('POST') || authBootstrapScript.includes('method: "POST"'));
+assert.ok(authBootstrapScript.includes('/login'));
+assert.ok(authBootstrapScript.includes('/accessToken'));
+assert.ok(authBootstrapScript.includes('RESOLVEIO_RUNNER_QA_CLIENT_URL'));
+assert.ok(authBootstrapScript.includes('RESOLVEIO_SUPPORT_QA_CLIENT_URL'));
+assert.ok(authBootstrapScript.includes('logoutExistingBrowserSession(page)'));
+assert.ok(authBootstrapScript.includes('navigator.serviceWorker.getRegistrations'));
+assert.ok(authBootstrapScript.includes('window.caches.keys'));
+assert.ok(authBootstrapScript.includes('window.indexedDB.databases'));
+assert.ok(authBootstrapScript.indexOf('await resetBrowserState(page);') < authBootstrapScript.indexOf('const auth = await login();'));
+assert.ok(authBootstrapScript.includes('localStorage.setItem("refreshToken"'));
+assert.ok(authBootstrapScript.includes('localStorage.setItem("accessToken"'));
+assert.ok(authBootstrapScript.includes('localStorage.setItem("user"'));
+assert.ok(authBootstrapScript.includes('auth-bootstrap-result.json'));
+assert.ok(authBootstrapScript.includes('auth-bootstrap-ready.png'));
+
+const localQaScript = buildResolveIORunnerLocalQaScript();
+const localQaStopperScript = buildResolveIORunnerLocalQaStopperScript();
+const bugfixComparisonScript = buildResolveIORunnerBugfixComparisonQaScript();
+const qaEnvScript = buildResolveIORunnerQaEnvScript({ mode: 'support' });
+
+assert.ok(qaEnvScript.includes('export IS_WORKERS_ENABLED=false'));
+assert.ok(qaEnvScript.includes('export IS_WORKER_INSTANCE=false'));
+assert.ok(qaEnvScript.includes('export SUPPORT_CODEX_MANAGER_PROCESS_ONLY=false'));
+assert.ok(qaEnvScript.includes('export SUPPORT_AUTO_MANAGER_PROCESS_ONLY=false'));
+assert.ok(qaEnvScript.includes('export AI_ASSISTANT_CODEX_MANAGER_PROCESS_ONLY=false'));
+assert.ok(qaEnvScript.includes('export PLAYWRIGHT_BROWSERS_PATH='));
+assert.ok(qaEnvScript.includes('chromium_headless_shell-*/chrome-headless-shell-linux64/chrome-headless-shell'));
+assert.ok(qaEnvScript.includes('chromium-*/chrome-linux64/chrome'));
+assert.ok(qaEnvScript.includes('/usr/bin/google-chrome-stable'));
+assert.ok(localQaScript.includes('kill_port_listeners "$port"'));
+assert.ok(localQaStopperScript.includes('kill_port_listeners "$port"'));
+assert.ok(localQaScript.includes('janitor_bounded 3 lsof'));
+assert.ok(localQaStopperScript.includes('janitor_bounded 3 lsof'));
+assert.ok(localQaStopperScript.includes('.qa.stop.lock'));
+assert.ok(localQaStopperScript.includes('refusing duplicate stopper'));
+assert.ok(localQaScript.includes('runner-process-manifest.json'));
+assert.ok(localQaScript.includes('janitor_write_manifest'));
+assert.ok(localQaScript.includes('janitor_start_heartbeat'));
+assert.ok(localQaScript.includes('janitor_update_lock_heartbeat'));
+assert.ok(localQaScript.includes('janitor_lock_is_live'));
+assert.ok(localQaScript.includes('refusing duplicate startup'));
+assert.ok(localQaScript.includes('janitor_check_resources || exit $?'));
+assert.ok(localQaScript.includes('exec >> "$ARTIFACT_DIR/runner.log" 2>&1'));
+assert.ok(localQaStopperScript.includes('runner-process-cleanup.json'));
+assert.ok(localQaStopperScript.includes('janitor_update_manifest_status stopped'));
+assert.ok(localQaScript.includes('kill_env_marked_processes'));
+assert.ok(localQaStopperScript.includes('kill_env_marked_processes'));
+assert.ok(localQaScript.includes('RESOLVEIO_RUNNER_QA_JOB_ID|RESOLVEIO_SUPPORT_QA_JOB_ID'));
+assert.ok(localQaStopperScript.includes('RESOLVEIO_RUNNER_QA_JOB_ID|RESOLVEIO_SUPPORT_QA_JOB_ID'));
+assert.ok(localQaScript.includes('[ -r "$env_file" ] || continue'));
+assert.ok(localQaStopperScript.includes('[ -r "$env_file" ] || continue'));
+assert.ok(localQaScript.includes('rm -rf "$LOCK_DIR"'));
+assert.ok(localQaStopperScript.includes('rm -rf "$ARTIFACT_DIR/.qa.lock"'));
+assert.ok(qaEnvScript.includes('RESOLVEIO_SUPPORT_QA_JOB_ID'));
+assert.equal(RunnerProcessJanitor.buildManifest({ jobId: 'job-1', clientPort: 4321 })['job_id'], 'job-1');
+assert.ok(!localQaScript.includes('index($0, artifact) && $0 ~ /(tee|tail|cat)/'));
+assert.ok(!localQaStopperScript.includes('index($0, artifact) && $0 ~ /(tee|tail|cat)/'));
+assert.ok(localQaScript.includes('local wait_until=$((SECONDS + 60))'));
+assert.ok(localQaStopperScript.includes('wait_until=$((SECONDS + 60))'));
+assert.ok(!localQaScript.includes('! kill -0 "$SERVER_PID"'));
+assert.ok(localQaScript.includes('if probe_url "$SERVER_URL"; then'));
+assert.ok(localQaScript.includes(': > "$ARTIFACT_DIR/server.log"'));
+assert.ok(localQaScript.includes(': > "$ARTIFACT_DIR/client.log"'));
+assert.ok(!localQaScript.includes('npm run server || ./start_server.sh'));
+assert.ok(localQaScript.includes('process.exit(p.scripts&&p.scripts.server?0:1)'));
+assert.ok(localQaScript.includes('$0 !~ /awk -v root=/'));
+assert.ok(localQaStopperScript.includes('$0 !~ /awk -v root=/'));
+assert.ok(localQaScript.includes('$0 !~ /run-local-qa\\.sh|stop-local-qa\\.sh|bugfix-comparison-qa\\.sh/'));
+assert.ok(localQaStopperScript.includes('$0 !~ /run-local-qa\\.sh|stop-local-qa\\.sh|bugfix-comparison-qa\\.sh/'));
+assert.ok(bugfixComparisonScript.includes('find "$ARTIFACT_DIR/$phase" -maxdepth 1 -type f'));
+assert.ok(bugfixComparisonScript.includes('tee "$ARTIFACT_DIR/$phase/qa-command.log"'));
+
+const bundle = buildResolveIORunnerPromptBundle({
+	context: 'ai_terminal',
+	objective: 'Fix the inventory list filter.',
+	blockers: [
+		'Browser QA failed on /inventory after clicking Filter.',
+		'Browser QA failed on /inventory after clicking Filter.'
+	],
+	relevantFiles: ['angular/app/inventory/inventory.component.ts'],
+	evidence: ['.build-output/inventory-filter.png'],
+	maxBlockers: 4
+});
+
+assert.equal(bundle.objective, 'Fix the inventory list filter.');
+assert.equal(bundle.contextLines.filter((line) => /Browser QA failed/i.test(line)).length, 1);
+assert.ok(bundle.fullPromptLines.some((line) => /Mandatory repair contract/i.test(line)));
+assert.ok(bundle.fullPromptLines.some((line) => /ResolveIO shared runner contract/i.test(line)));
+
+assert.equal(
+	normalizeResolveIORunnerBlocker('Attempt 2 failed at server/src/methods/demo.ts:123 line 123'),
+	'attempt # failed at server/src/methods/demo.ts:# line #'
+);
+assert.equal(classifyResolveIORunnerBlocker('Reviewer found a database call inside loop'), 'db_call_inside_loop');
+assert.equal(
+	classifyResolveIORunnerBlocker('QA compile preflight failed: geochem/angular/app/schedule.ts:42 error TS2554: Expected 0 arguments, but got 1. yardsForUser(this.id_driver) from angular/app/publications.ts'),
+	'user_specific_publication_argument_mismatch'
+);
+assert.equal(
+	classifyResolveIORunnerBlocker('QA compile preflight failed before browser testing: Fix the Angular publication signature mismatch causing the `yardsForUser(...)` compile errors, then rerun QA.'),
+	'user_specific_publication_argument_mismatch'
+);
+assert.equal(
+	classifyResolveIORunnerBlocker('QA coverage matrix is incomplete: limited smoke only proves headers; missing tax and inventory persisted result checks.'),
+	'qa_coverage_incomplete'
+);
+
+const qaCoverageChecklist = buildResolveIORunnerQaCoverageChecklist({
+	ticketText: 'Invoice line item surcharge must update sales tax and inventory transactions.',
+	changedFiles: ['geochem/angular/app/invoice/new/invoice-new.component.ts', 'geochem/server/src/methods/invoices.ts']
+});
+assert.ok(qaCoverageChecklist.some((line) => /Invoice\/billing\/tax coverage/i.test(line)));
+assert.ok(qaCoverageChecklist.some((line) => /Inventory coverage/i.test(line)));
+assert.ok(qaCoverageChecklist.some((line) => /row\/value assertion/i.test(line)));
+
+const repairPlans = buildResolveIORunnerRepairPlans({
+	context: 'support_ticket',
+	includeDevServerRules: true,
+	blockers: [
+		'Reviewer found a database call inside loop in server/src/methods/invoices.ts:44 loop starts near line 40'
+	],
+	changedFiles: ['server/src/methods/invoices.ts'],
+	gateSource: 'pr_quality_review'
+});
+
+assert.equal(repairPlans.length, 1);
+assert.equal(repairPlans[0].blockerClass, 'db_call_inside_loop');
+assert.deepEqual(repairPlans[0].targetFiles, ['server/src/methods/invoices.ts']);
+assert.ok(repairPlans[0].lineHints.includes('line 44'));
+assert.ok(repairPlans[0].repairRecipe.some((line) => /batched/i.test(line)));
+assert.ok(repairPlans[0].passingCondition.includes('No loop'));
+
+const userSpecificRepairPlans = buildResolveIORunnerRepairPlans({
+	context: 'support_ticket',
+	includeDevServerRules: true,
+	blockers: [
+		'QA compile preflight failed: geochem/angular/app/schedule.ts:42 error TS2554: Expected 0 arguments, but got 1. yardsForUser(this.id_driver) from angular/app/publications.ts'
+	],
+	changedFiles: ['geochem/angular/app/publications.ts', 'geochem/angular/app/schedule.ts'],
+	gateSource: 'qa_compile_preflight'
+});
+
+assert.equal(userSpecificRepairPlans[0].blockerClass, 'user_specific_publication_argument_mismatch');
+assert.ok(userSpecificRepairPlans[0].repairRecipe.some((line) => /inject.*logged-in socket user.*first server parameter/i.test(line)));
+assert.ok(userSpecificRepairPlans[0].repairRecipe.some((line) => /id_current_user: string, id_user\?: string/i.test(line)));
+
+const coverageRepairPlans = buildResolveIORunnerRepairPlans({
+	context: 'support_ticket',
+	includeDevServerRules: true,
+	blockers: [
+		'QA coverage matrix incomplete: only showed surcharge buttons; missing invoice create/edit/reopen, tax totals, inventory transaction side effects, and persisted result assertions.'
+	],
+	changedFiles: [
+		'geochem/angular/app/invoice/new/invoice-new.component.ts',
+		'geochem/server/src/methods/invoices.ts',
+		'geochem/server/src/collections/customer.collection.ts'
+	],
+	gateSource: 'qa_browser_validation'
+});
+
+assert.equal(coverageRepairPlans[0].blockerClass, 'qa_coverage_incomplete');
+assert.ok(coverageRepairPlans[0].repairRecipe.some((line) => /QA Coverage Matrix/i));
+assert.ok(coverageRepairPlans[0].repairRecipe.some((line) => /Invoice\/billing\/tax coverage/i));
+assert.ok(coverageRepairPlans[0].requiredProof.some((line) => /persisted row\/value assertions/i));
+
+assert.deepEqual(
+	findRepeatedResolveIORunnerBlockers(
+		['Attempt 1 failed at server/src/methods/demo.ts:123 line 123'],
+		['Attempt 2 failed at server/src/methods/demo.ts:456 line 456']
+	),
+	['Attempt 2 failed at server/src/methods/demo.ts:456 line 456']
+);
+
+assert.equal(decideResolveIORunnerRepairContinuation({
+	currentBlockers: ['Generated file mismatch in angular/app/publications.ts'],
+	activeContractBlockers: ['yardsForUser publication signature mismatch'],
+	currentAttempt: 3,
+	maxAttempts: 3,
+	currentRepairWaveCount: 1,
+	maxRepairWaves: 4
+}).action, 'start_repair_wave');
+
+assert.equal(decideResolveIORunnerRepairContinuation({
+	currentBlockers: ['yardsForUser publication signature mismatch at line 80'],
+	activeContractBlockers: ['yardsForUser publication signature mismatch at line 40'],
+	currentAttempt: 2,
+	maxAttempts: 3,
+	currentRepairWaveCount: 0,
+	maxRepairWaves: 4
+}).action, 'park_repeated_blocker');
+
+assert.equal(decideResolveIORunnerRepairContinuation({
+	currentBlockers: ['Browser QA still fails on /manage'],
+	activeContractBlockers: ['Browser QA still fails on /manage'],
+	diffHash: 'same',
+	evidenceHash: 'same',
+	previousDiffHash: 'same',
+	previousEvidenceHash: 'same'
+}).action, 'park_no_progress');
+
+const artifactRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'resolveio-runner-artifacts-'));
+const projectRoot = path.join(artifactRoot, 'resolveio-all', 'geochem');
+const qaRoot = path.join(projectRoot, 'qa-artifacts');
+fs.mkdirSync(qaRoot, { recursive: true });
+const screenshotPath = path.join(qaRoot, 'billing-dashboard-surcharge.png');
+fs.writeFileSync(screenshotPath, 'fake png bytes');
+
+const artifactPaths = collectResolveIORunnerEvidenceArtifactPaths({
+	job: {
+		workspacePath: artifactRoot,
+		projectRoot: 'resolveio-all/geochem',
+		tasks: [{
+			notes: 'QA passed. Screenshot: qa-artifacts/billing-dashboard-surcharge.png'
+		}]
+	}
+});
+
+assert.deepEqual(artifactPaths, [screenshotPath]);
+
+let uploadedCount = 0;
+persistResolveIORunnerEvidenceArtifacts({
+	job: {
+		workspacePath: artifactRoot,
+		projectRoot: 'resolveio-all/geochem',
+		tasks: [{
+			notes: 'QA passed. Screenshot: qa-artifacts/billing-dashboard-surcharge.png'
+		}]
+	},
+	ticketUrl: 'https://resolveio.test/support/004333',
+	uploadFile: async (input) => {
+		uploadedCount += 1;
+		assert.equal(input.filename, 'billing-dashboard-surcharge.png');
+		assert.equal(input.contentType, 'image/png');
+		assert.equal(input.size, Buffer.from('fake png bytes').length);
+		return {
+			_id: 'file-qa-1',
+			key: 'uploads/qa/billing-dashboard-surcharge.png',
+			name: input.filename
+		};
+	}
+}).then((result) => {
+	assert.equal(uploadedCount, 1);
+	assert.deepEqual(result.fileIds, ['file-qa-1']);
+	assert.equal(result.files[0].key, 'uploads/qa/billing-dashboard-surcharge.png');
+	assert.equal(result.attachments[0].uploaded_to_support_ticket, true);
+}).catch((error) => {
+	throw error;
+});

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();
+