fix(vscode): stop the .kaoto metadata lookup at the workspace root

- findExistingKaotoMetadataFile walked up to the filesystem root, so a
  .kaoto file in the home directory was found for every project below it
  and no new file was created in the workspace. Stop at the workspace
  folder, letting vscode.workspace.getWorkspaceFolder() decide the
  boundary; outside a workspace only check the folder of the Camel route.
- findKaotoMetadataToCreate used path.basename instead of path.dirname
  when there is no workspace, so the file was created at a wrong location
  instead of next to the Camel route.
- Add tests for both lookups, including a .kaoto file above the workspace
  root that must be ignored.

Author: mmelko

packages/kaoto-vscode/src/test/webview/VSCodeKaotoEditorChannelApiMetadataFile.test.ts

@@ -0,0 +1,140 @@
+/**
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { expect } from 'chai';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import * as vscode from 'vscode';
+import { VSCodeKaotoEditorChannelApi } from '../../webview/VSCodeKaotoEditorChannelApi';
+import { getTestWorkspaceFolder } from '../utils/TestSetup';
+
+/**
+ * The lookup of the `.kaoto` metadata file only depends on the edited document URI,
+ * so the private methods are invoked on a minimal object instead of a full editor channel.
+ */
+interface MetadataFileLookup {
+	findExistingKaotoMetadataFile(fileUri: vscode.Uri): Promise<vscode.Uri | undefined>;
+	findKaotoMetadataToCreate(): Promise<vscode.Uri>;
+}
+
+function createApi(documentUri: vscode.Uri): MetadataFileLookup {
+	const api = Object.create(VSCodeKaotoEditorChannelApi.prototype);
+	api.currentEditedDocument = { uri: documentUri };
+	return api as MetadataFileLookup;
+}
+
+suite('VSCodeKaotoEditorChannelApi .kaoto metadata file lookup', () => {
+	let workspaceFolder: string;
+	let workspaceKaoto: string;
+	let workspaceKaotoBackup: string | undefined;
+	let outsideRoot: string;
+	let parentKaoto: string;
+
+	setup(() => {
+		workspaceFolder = getTestWorkspaceFolder();
+		workspaceKaoto = path.join(workspaceFolder, '.kaoto');
+		// The parent of the workspace folder plays the role of the user home directory
+		parentKaoto = path.join(path.dirname(workspaceFolder), '.kaoto');
+
+		// The fixture ships a .kaoto in the workspace root; move it aside so that it does not shadow the cases below
+		workspaceKaotoBackup = undefined;
+		if (fs.existsSync(workspaceKaoto)) {
+			workspaceKaotoBackup = `${workspaceKaoto}.bak`;
+			fs.renameSync(workspaceKaoto, workspaceKaotoBackup);
+		}
+
+		outsideRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'kaoto-metadata-outside-'));
+	});
+
+	teardown(() => {
+		fs.rmSync(parentKaoto, { force: true });
+		fs.rmSync(workspaceKaoto, { force: true });
+		if (workspaceKaotoBackup) {
+			fs.renameSync(workspaceKaotoBackup, workspaceKaoto);
+		}
+		fs.rmSync(outsideRoot, { recursive: true, force: true });
+	});
+
+	suite('findExistingKaotoMetadataFile', () => {
+		test('finds the .kaoto file at the workspace root', async () => {
+			fs.writeFileSync(workspaceKaoto, '{}');
+			const route = vscode.Uri.file(path.join(workspaceFolder, 'routes', 'a.camel.yaml'));
+
+			const found = await createApi(route).findExistingKaotoMetadataFile(route);
+
+			expect(found?.fsPath).to.equal(vscode.Uri.file(workspaceKaoto).fsPath);
+		});
+
+		test('does not look above the workspace root, e.g. into the home directory', async () => {
+			fs.writeFileSync(parentKaoto, '{"leaked":"from-another-project"}');
+			const route = vscode.Uri.file(path.join(workspaceFolder, 'routes', 'a.camel.yaml'));
+
+			const found = await createApi(route).findExistingKaotoMetadataFile(route);
+
+			expect(found).to.equal(undefined);
+		});
+
+		test('prefers the workspace .kaoto over one located above the workspace root', async () => {
+			fs.writeFileSync(parentKaoto, '{}');
+			fs.writeFileSync(workspaceKaoto, '{}');
+			const route = vscode.Uri.file(path.join(workspaceFolder, 'a.camel.yaml'));
+
+			const found = await createApi(route).findExistingKaotoMetadataFile(route);
+
+			expect(found?.fsPath).to.equal(vscode.Uri.file(workspaceKaoto).fsPath);
+		});
+
+		test('outside of any workspace, does not walk up the directory tree', async () => {
+			fs.writeFileSync(path.join(outsideRoot, '.kaoto'), '{}');
+			const route = vscode.Uri.file(path.join(outsideRoot, 'nested', 'a.camel.yaml'));
+
+			const found = await createApi(route).findExistingKaotoMetadataFile(route);
+
+			expect(found).to.equal(undefined);
+		});
+
+		test('outside of any workspace, finds the .kaoto next to the route', async () => {
+			const nested = path.join(outsideRoot, 'nested');
+			fs.mkdirSync(nested);
+			fs.writeFileSync(path.join(nested, '.kaoto'), '{}');
+			const route = vscode.Uri.file(path.join(nested, 'a.camel.yaml'));
+
+			const found = await createApi(route).findExistingKaotoMetadataFile(route);
+
+			expect(found?.fsPath).to.equal(vscode.Uri.file(path.join(nested, '.kaoto')).fsPath);
+		});
+	});
+
+	suite('findKaotoMetadataToCreate', () => {
+		test('creates the .kaoto file at the workspace root', async () => {
+			const route = vscode.Uri.file(path.join(workspaceFolder, 'routes', 'a.camel.yaml'));
+
+			const toCreate = await createApi(route).findKaotoMetadataToCreate();
+
+			expect(toCreate.fsPath).to.equal(vscode.Uri.file(workspaceKaoto).fsPath);
+		});
+
+		test('outside of any workspace, creates the .kaoto file next to the route', async () => {
+			const nested = path.join(outsideRoot, 'nested');
+			const route = vscode.Uri.file(path.join(nested, 'a.camel.yaml'));
+
+			const toCreate = await createApi(route).findKaotoMetadataToCreate();
+
+			expect(toCreate.fsPath).to.equal(vscode.Uri.file(path.join(nested, '.kaoto')).fsPath);
+		});
+	});
+});

packages/kaoto-vscode/src/webview/VSCodeKaotoEditorChannelApi.ts

@@ -319,26 +319,39 @@ export class VSCodeKaotoEditorChannelApi extends DefaultVsCodeKieEditorChannelAp
 		}
 	}
 
+	/**
+	 * Look for a .kaoto file from the folder of the given file up to the workspace folder (included).
+	 * The lookup never goes above the workspace folder, so a .kaoto file located elsewhere (e.g. in the user home directory) is ignored.
+	 * When the file is not in a workspace folder, only the folder containing the file is checked.
+	 */
 	private async findExistingKaotoMetadataFile(fileUri: vscode.Uri): Promise<vscode.Uri | undefined> {
-		const parentFolder = path.dirname(fileUri.fsPath);
-		if (parentFolder === fileUri.fsPath || parentFolder === '' || parentFolder === undefined) {
-			return undefined;
-		}
-		try {
-			const kaotoMetadataFileCandidate = vscode.Uri.file(path.join(parentFolder, '.kaoto'));
-			await vscode.workspace.fs.stat(kaotoMetadataFileCandidate);
-			return kaotoMetadataFileCandidate;
-		} catch {
-			return this.findExistingKaotoMetadataFile(vscode.Uri.file(parentFolder));
+		const workspaceFolder = vscode.workspace.getWorkspaceFolder(fileUri)?.uri.toString();
+		let folder = path.dirname(fileUri.fsPath);
+		while (true) {
+			const kaotoMetadataFileCandidate = vscode.Uri.file(path.join(folder, '.kaoto'));
+			try {
+				await vscode.workspace.fs.stat(kaotoMetadataFileCandidate);
+				return kaotoMetadataFileCandidate;
+			} catch {
+				// not in this folder, try the parent one if allowed
+			}
+			const parentFolder = path.dirname(folder);
+			// Let VS Code decide containment: comparing paths breaks on case-insensitive file systems and on Windows drive letters.
+			const isParentInWorkspaceFolder =
+				workspaceFolder !== undefined && vscode.workspace.getWorkspaceFolder(vscode.Uri.file(parentFolder))?.uri.toString() === workspaceFolder;
+			if (parentFolder === folder || !isParentInWorkspaceFolder) {
+				return undefined;
+			}
+			folder = parentFolder;
 		}
 	}
 
 	private async findKaotoMetadataToCreate(): Promise<vscode.Uri> {
 		const workspaceFolder = vscode.workspace.getWorkspaceFolder(this.currentEditedDocument.uri);
 		if (workspaceFolder !== undefined) {
-			return vscode.Uri.file(path.join(workspaceFolder?.uri.fsPath, '.kaoto'));
+			return vscode.Uri.file(path.join(workspaceFolder.uri.fsPath, '.kaoto'));
 		} else {
-			const parentFolder = path.basename(path.dirname(this.currentEditedDocument.uri.fsPath));
+			const parentFolder = path.dirname(this.currentEditedDocument.uri.fsPath);
 			return vscode.Uri.file(path.join(parentFolder, '.kaoto'));
 		}
 	}