Resolve cbuild-run dir relative to workspace (#815)

* Resolve cbuild-run dir relative to workspace
* Make snapshot tests OS agnostic
* comparePath function to handle differing drive letter casings
* Treat empty and undefined CMSIS_PACK_ROOT the same

Author: jreineckearm

src/cbuild-run/__snapshots__/cbuild-run-reader.test.ts.snap

@@ -2,6 +2,7 @@
 
 exports[`CbuildRunReader Parser successfully parses a *.cbuild-run.yml file 1`] = `
 {
+  "cbuildRunDir": Any<String>,
   "compiler": "AC6",
   "debug-sequences": [
     {

src/cbuild-run/cbuild-run-reader.test.ts

@@ -16,6 +16,7 @@
 
 import * as path from 'path';
 import { CbuildRunReader } from './cbuild-run-reader';
+import { getCmsisPackRootPath } from '../utils';
 
 const TEST_CBUILD_RUN_FILE = 'test-data/multi-core.cbuild-run.yml'; // Relative to repo root
 const TEST_FILE_PATH = 'test-data/fileReaderTest.txt'; // Relative to repo root
@@ -24,6 +25,35 @@ const PACK_ROOT = '/my/pack/root';
 const EXPECTED_CUSTOM_SVD = path.resolve(path.dirname(TEST_CBUILD_RUN_FILE), '../../MyDevice/multi-core-custom.svd');
 const EXPECTED_CUSTOM_SCVD = path.resolve(path.dirname(TEST_CBUILD_RUN_FILE), '../../MyDevice/multi-core-custom.scvd');
 
+// Compare function that compares path and allows differing drive letter casing on Windows.
+const comparePath = (received: string|undefined, expected: string): boolean => {
+    if (!received) {
+        return false;
+    }
+    // Exact match first, majority of cases.
+    if (received === expected) {
+        return true;
+    }
+    // Exit if not Windows, no match
+    if (process.platform !== 'win32') {
+        return false;
+    }
+    // Split drive letter from path. Assumption: no URLs, no other colons in folder names.
+    const receivedFragments = received.split(':');
+    const expectedFragments = expected.split(':');
+    if (receivedFragments.length !== expectedFragments.length) {
+        return false;
+    }
+    return receivedFragments.every((receivedFragment, index) => {
+        // eslint-disable-next-line security/detect-object-injection
+        const expectedFragment = expectedFragments[index];
+        if (index === 0) {
+            // Drive letter
+            return receivedFragment.toLowerCase() === expectedFragment.toLowerCase();
+        }
+        return receivedFragment === expectedFragment;
+    });
+};
 
 describe('CbuildRunReader', () => {
 
@@ -34,7 +64,12 @@ describe('CbuildRunReader', () => {
             expect(cbuildRunReader.hasContents()).toBe(true);
             const contents = cbuildRunReader.getContents();
             expect(contents).toBeDefined();
-            expect(contents).toMatchSnapshot();
+            // Snapshot match all but cbuildRunDir which is an absolute path and hence OS specific.
+            // That part gets tested in separate tests.
+            expect({
+                ...contents,
+                cbuildRunDir: expect.any(String)
+            }).toMatchSnapshot();
         });
 
         it('throws if it parses something other than a *.cbuild-run.yml file and correctly responds to raw contents calls', async () => {
@@ -96,8 +131,8 @@ describe('CbuildRunReader', () => {
                 // eslint-disable-next-line security/detect-object-injection
                 const expectedPath = path.normalize(path.resolve(expectedSvdPaths[i]));
                 // eslint-disable-next-line security/detect-object-injection
-                const actualPath = path.normalize(path.resolve(svdFilePaths[i]));
-                expect(expectedPath).toEqual(actualPath);
+                const actualPath = svdFilePaths[i];
+                expect(comparePath(actualPath, expectedPath)).toBe(true);
             }
         });
 
@@ -117,21 +152,26 @@ describe('CbuildRunReader', () => {
             expect(pnames).toEqual(['Core0', 'Core1']);
         });
 
-        it('includes descriptors without pname when filtering by pname (SVD)', async () => {
+        it.each([
+            { packRoot: '', info: 'empty string' },
+            { packRoot: undefined, info: 'undefined' },
+        ])('includes descriptors without pname when filtering by pname (SVD) and uses default pack root if input is $info', async ({ packRoot }) => {
             await cbuildRunReader.parse(TEST_CBUILD_RUN_FILE);
             const cbuildRun = (cbuildRunReader as unknown as { cbuildRun?: { ['system-descriptions']?: Array<{ file: string; type: string; pname?: string }> } }).cbuildRun;
             const systemDescriptions = cbuildRun?.['system-descriptions'];
             expect(systemDescriptions).toBeDefined();
-            const svdPaths = cbuildRunReader.getSvdFilePaths('', 'Core1');
-            expect(svdPaths.map(path.normalize)).toEqual([
+            const svdPaths = cbuildRunReader.getSvdFilePaths(packRoot, 'Core1');
+            const expectedSvdPaths = [
                 path.normalize(
-                    path.resolve(path.dirname(TEST_CBUILD_RUN_FILE), '${CMSIS_PACK_ROOT}', 'MyVendor', 'MyDevice', '1.0.0', 'Debug', 'SVD', 'MyDevice_Core1.svd')
+                    path.resolve(getCmsisPackRootPath(), 'MyVendor', 'MyDevice', '1.0.0', 'Debug', 'SVD', 'MyDevice_Core1.svd')
                 ),
                 path.normalize(
-                    path.resolve(path.dirname(TEST_CBUILD_RUN_FILE), '${CMSIS_PACK_ROOT}', 'MyVendor', 'MyDevice', '1.0.0', 'Debug', 'SVD', 'MyDevice_generic.svd')
+                    path.resolve(getCmsisPackRootPath(), 'MyVendor', 'MyDevice', '1.0.0', 'Debug', 'SVD', 'MyDevice_generic.svd')
                 ),
                 path.normalize(EXPECTED_CUSTOM_SVD),
-            ]);
+            ];
+            // eslint-disable-next-line security/detect-object-injection
+            svdPaths.forEach((svdPath, index) => expect(comparePath(svdPath, expectedSvdPaths[index])).toBe(true));
         });
 
         it('includes descriptors without pname when filtering by pname (SVD)', async () => {
@@ -140,12 +180,13 @@ describe('CbuildRunReader', () => {
             const systemDescriptions = cbuildRun?.['system-descriptions'];
             expect(systemDescriptions).toBeDefined();
             const svdPaths = cbuildRunReader.getSvdFilePaths(PACK_ROOT, 'Core1');
-
-            expect(svdPaths.map(path.normalize)).toEqual([
+            const expectedSvdPaths = [
                 path.normalize(path.resolve(PACK_ROOT, 'MyVendor', 'MyDevice', '1.0.0', 'Debug', 'SVD', 'MyDevice_Core1.svd')),
                 path.normalize(path.resolve(PACK_ROOT, 'MyVendor', 'MyDevice', '1.0.0', 'Debug', 'SVD', 'MyDevice_generic.svd')),
                 path.normalize(EXPECTED_CUSTOM_SVD),
-            ]);
+            ];
+            // eslint-disable-next-line security/detect-object-injection
+            svdPaths.forEach((svdPath, index) => expect(comparePath(svdPath, expectedSvdPaths[index])).toBe(true));
         });
 
         it('includes descriptors without pname when filtering by pname (SCVD)', async () => {
@@ -154,28 +195,43 @@ describe('CbuildRunReader', () => {
             const systemDescriptions = cbuildRun?.['system-descriptions'] ?? [];
             expect(systemDescriptions).toBeDefined();
             const scvdPaths = cbuildRunReader.getScvdFilePaths(PACK_ROOT, 'Core1');
-
-            expect(scvdPaths).toEqual([
+            const expectedScvdPaths = [
                 path.normalize(path.resolve(PACK_ROOT, 'MyVendor', 'MyDevice', '1.0.0', 'Debug', 'SCVD', 'MySoftware_component.scvd')),
                 path.normalize(EXPECTED_CUSTOM_SCVD),
                 path.normalize(path.resolve(PACK_ROOT, 'MyVendor', 'MyDevice', '1.0.0', 'Debug', 'SCVD', 'Core1.scvd')),
-            ]);
+            ];
+            // eslint-disable-next-line security/detect-object-injection
+            scvdPaths.forEach((scvdPath, index) => expect(comparePath(scvdPath, expectedScvdPaths[index])).toBe(true));
         });
 
-        it('resolves relative SVD paths relative to the cbuild-run.yml file location', async () => {
-            await cbuildRunReader.parse(TEST_CBUILD_RUN_FILE);
+        it.each([
+            {
+                cbuildRunFile: TEST_CBUILD_RUN_FILE,
+            },
+            {
+                cbuildRunFile: `.${path.sep}${TEST_CBUILD_RUN_FILE}`,
+            },
+        ])('resolves relative SVD paths relative to the cbuild-run.yml file location ($cbuildRunFile)', async ({ cbuildRunFile }) => {
+            await cbuildRunReader.parse(cbuildRunFile);
             const svdFilePaths = cbuildRunReader.getSvdFilePaths(PACK_ROOT);
             const expectedTail = path.normalize(path.join('MyDevice', 'multi-core-custom.svd'));
             const resolvedCustom = svdFilePaths.find((p: string) => p.endsWith(expectedTail));
-            expect(resolvedCustom).toEqual(path.normalize(EXPECTED_CUSTOM_SVD));
+            expect(comparePath(resolvedCustom, path.normalize(EXPECTED_CUSTOM_SVD))).toBe(true);
         });
 
-        it('resolves relative SCVD paths relative to the cbuild-run.yml file location', async () => {
-            await cbuildRunReader.parse(TEST_CBUILD_RUN_FILE);
+        it.each([
+            {
+                cbuildRunFile: TEST_CBUILD_RUN_FILE,
+            },
+            {
+                cbuildRunFile: `.${path.sep}${TEST_CBUILD_RUN_FILE}`,
+            },
+        ])('resolves relative SCVD paths relative to the cbuild-run.yml file location ($cbuildRunFile)', async ({ cbuildRunFile }) => {
+            await cbuildRunReader.parse(cbuildRunFile);
             const scvdFilePaths = cbuildRunReader.getScvdFilePaths(PACK_ROOT);
             const expectedTail = path.normalize(path.join('MyDevice', 'multi-core-custom.scvd'));
             const resolvedCustom = scvdFilePaths.find((p: string) => p.endsWith(expectedTail));
-            expect(resolvedCustom).toEqual(path.normalize(EXPECTED_CUSTOM_SCVD));
+            expect(comparePath(resolvedCustom, path.normalize(EXPECTED_CUSTOM_SCVD))).toBe(true);
         });
     });
 });

src/cbuild-run/cbuild-run-reader.ts

@@ -14,8 +14,9 @@
  * limitations under the License.
  */
 
-import * as yaml from 'yaml';
 import * as path from 'path';
+import * as vscode from 'vscode';
+import * as yaml from 'yaml';
 import { CbuildRunRootType, CbuildRunType } from './cbuild-run-types';
 import { FileReader, VscodeFileReader } from '../desktop/file-reader';
 import { getCmsisPackRootPath } from '../utils';
@@ -45,7 +46,10 @@ export class CbuildRunReader {
             throw new Error(`Invalid '*.cbuild-run.yml' file: ${filePath}`);
         }
         this.cbuildRunFilePath = filePath;
-        this.cbuildRunDir = path.dirname(this.cbuildRunFilePath);
+        const dirName = path.dirname(this.cbuildRunFilePath);
+        const workspace = vscode.workspace.workspaceFolders?.at(0)?.uri.fsPath;
+        // Only considers workspace if dirName is not absolute.
+        this.cbuildRunDir = workspace ? path.resolve(workspace, dirName) : dirName;
     }
 
     public getSvdFilePaths(cmsisPackRoot?: string, pname?: string): string[] {
@@ -68,8 +72,8 @@ export class CbuildRunReader {
         if (fileDescriptors.length === 0) {
             return [];
         }
-        // Replace potential ${CMSIS_PACK_ROOT} placeholder
-        const effectiveCmsisPackRoot = cmsisPackRoot ?? getCmsisPackRootPath();
+        // Replace potential ${CMSIS_PACK_ROOT} placeholder, treat empty string and undefined the same.
+        const effectiveCmsisPackRoot = cmsisPackRoot || getCmsisPackRootPath();
         // Map to copies, leave originals untouched, if file descriptors do not have a pname, always include it
         const filteredDescriptors = pname ? fileDescriptors.filter(descriptor => {
             if (!descriptor.pname) {

src/debug-session/__snapshots__/gdbtarget-debug-session.test.ts.snap

@@ -1,7 +1,7 @@
 // Jest Snapshot v1, https://jestjs.io/docs/snapshot-testing
 
 exports[`GDBTargetDebugSession with launch configuration returns a cbuild object and cbuild run path after parsing one 1`] = `
-CbuildRunReader {
+{
   "cbuildRun": {
     "compiler": "AC6",
     "debug-sequences": [
@@ -182,7 +182,7 @@ CbuildRunReader {
     },
     "target-type": "My-Test-Target-Type",
   },
-  "cbuildRunDir": "test-data",
+  "cbuildRunDir": Any<String>,
   "cbuildRunFilePath": "test-data/multi-core.cbuild-run.yml",
   "reader": VscodeFileReader {},
 }

src/debug-session/gdbtarget-debug-session.test.ts

@@ -72,7 +72,12 @@ describe('GDBTargetDebugSession', () => {
         it('returns a cbuild object and cbuild run path after parsing one', async () => {
             await gdbTargetSession.parseCbuildRun(TEST_CBUILD_RUN_FILE);
             const cbuildRun = await gdbTargetSession.getCbuildRun();
-            expect(cbuildRun).toMatchSnapshot();
+            // Snapshot match all but cbuildRunDir which is an absolute path and hence OS specific.
+            // That part gets tested separately in cbuild-run-reader.test.ts.
+            expect({
+                ...cbuildRun,
+                cbuildRunDir: expect.any(String)
+            }).toMatchSnapshot();
         });
 
         it('evaluates a global expression without active stack frame and returns a value', async () => {