fix: use exit code to detect missing programmer

Signed-off-by: Akos Kitta <a.kitta@arduino.cc>

Author: Akos Kitta

build-artifacts/vscode-arduino-tools-0.1.0-beta.1.vsix

@@ -429,17 +429,23 @@ async function cliExec<T = Record<string, unknown>>(
       try {
         const object = JSON.parse(err.stderr);
         if (isCommandError(object)) {
-          cliError = new CliError(object.error);
+          cliError = new CliError(object.error, err.exitCode);
         }
       } catch {}
     }
     throw cliError ?? err;
   }
 }
 
-function isExecaError(arg: unknown): arg is Error & { stderr: string } {
+function isExecaError(
+  arg: unknown
+): arg is Error & { stderr: string; exitCode: number | undefined } {
   return (
-    arg instanceof Error && 'stderr' in arg && typeof arg.stderr === 'string'
+    arg instanceof Error &&
+    'stderr' in arg &&
+    typeof arg.stderr === 'string' &&
+    'exitCode' in arg &&
+    (typeof arg.exitCode === 'number' || typeof arg.exitCode === 'undefined')
   );
 }
 
@@ -456,12 +462,20 @@ function isCommandError(arg: unknown): arg is CommandError {
 }
 
 export class CliError extends Error {
-  constructor(message: string) {
+  constructor(message: string, readonly exitCode: number | undefined) {
     super(message);
     Object.setPrototypeOf(this, CliError.prototype);
   }
 }
 
+// https://github.com/arduino/arduino-cli/blob/b41f4044cac6ab7f7d853e368bc31e5d626d63d4/internal/cli/feedback/errorcodes.go#L57-L58
+const missingProgrammerCode = 11 as const;
+function isMissingProgrammerError(
+  arg: unknown
+): arg is CliError & { exitCode: typeof missingProgrammerCode } {
+  return arg instanceof CliError && arg.exitCode === missingProgrammerCode;
+}
+
 // Remove index signature
 // https://stackoverflow.com/a/51956054/5529090
 type RemoveIndex<T> = {
@@ -495,5 +509,6 @@ export const __tests__ = {
   mergeLaunchConfig,
   updateLaunchConfigs,
   isCommandError,
+  isMissingProgrammerError,
   cliExec,
 } as const;

src/debug.ts

@@ -6,7 +6,12 @@ import { __tests__ } from '../../debug';
 import { exec } from '../../exec';
 import { TestEnv } from '../testEnv';
 
-const { CliError, buildDebugInfoArgs, createLaunchConfig } = __tests__;
+const {
+  CliError,
+  buildDebugInfoArgs,
+  createLaunchConfig,
+  isMissingProgrammerError,
+} = __tests__;
 
 describe('debug (slow)', () => {
   let testEnv: TestEnv;
@@ -35,7 +40,7 @@ describe('debug (slow)', () => {
       const actual = await createLaunchConfig({
         board: { fqbn },
         cliPath: testEnv.cliPath,
-        cliConfigPath: testEnv.cliConfigPath,
+        cliConfigPath: testEnv.cliConfigPaths['en'],
         sketchPath,
         programmer,
       });
@@ -93,13 +98,20 @@ describe('debug (slow)', () => {
     assert.ok(typeof object === 'object');
   });
 
-  it('should fail when the programmer is missing', async () => {
-    await assert.rejects(
-      cliExec(['debug', '-I', '-b', 'arduino:esp32:nano_nora', sketchPath]),
-      (reason) =>
-        reason instanceof CliError && /missing programmer/i.test(reason.message)
-    );
-  });
+  ['en', 'it'].map((locale) =>
+    it(`should fail when the programmer is missing (locale: ${locale})`, async function () {
+      if (!testEnv.cliConfigPaths[locale]) {
+        this.skip();
+      }
+      await assert.rejects(
+        cliExec(
+          ['debug', '-I', '-b', 'arduino:esp32:nano_nora', sketchPath],
+          locale
+        ),
+        (reason) => isMissingProgrammerError(reason)
+      );
+    })
+  );
 
   it('should fail when the programmer is unknown', async () => {
     await assert.rejects(
@@ -135,8 +147,12 @@ describe('debug (slow)', () => {
     return sketchPath;
   }
 
-  async function cliExec<T>(args: string[]): Promise<T> {
-    return __tests__.cliExec(testEnv.cliPath, args, testEnv.cliConfigPath);
+  async function cliExec<T>(args: string[], locale = 'en'): Promise<T> {
+    return __tests__.cliExec(
+      testEnv.cliPath,
+      args,
+      testEnv.cliConfigPaths[locale]
+    );
   }
 
   function fromDataDir(...paths: string[]): string {

src/test/suite/debug.slow-test.ts

@@ -75,18 +75,24 @@ const cliFilename = `arduino-cli${os.platform() === 'win32' ? '.exe' : ''}`;
 const cliPath = path.join(testsPath, cliFilename);
 
 async function setup(tracked: typeof temp): Promise<TestEnv> {
-  const cliConfigPath = path.join(testsPath, 'arduino-cli.yaml');
+  const cliConfigPaths = {
+    en: path.join(testsPath, 'arduino-cli.yaml'),
+    it: path.join(testsPath, 'arduino-cli-it.yaml'),
+  } as const;
   const testEnv: TestEnv = {
-    cliConfigPath,
+    cliConfigPaths,
     cliPath,
     dataDirPath,
     userDirPath,
     tracked,
+    get cliConfigPath() {
+      return cliConfigPaths['en'];
+    },
   };
   const params: PrepareTestEnvParams = {
     ...testEnv,
     platformsToInstall: ['arduino:esp32', 'arduino:samd'], // samd is need to get the tools for the manually (Git) installed core
   };
   await prepareTestEnv(params);
-  return params;
+  return testEnv;
 }

src/test/suite/index.ts

@@ -7,16 +7,24 @@ import { exec } from '../exec';
 
 export interface TestEnv {
   readonly cliPath: string;
-  /**
-   * Config will be overwritten if exists.
-   */
-  readonly cliConfigPath: string;
   readonly userDirPath: string;
   readonly dataDirPath: string;
   readonly tracked: typeof temp;
+  /**
+   * The keys are locales values are the absolute filesystem path of the CLI configuration with the pre-configured `locale`.
+   */
+  readonly cliConfigPaths: Readonly<{
+    en: string;
+    [local: string]: string;
+  }>;
+
+  /**
+   * Sugar for `cliConfigPaths['en']`
+   */
+  get cliConfigPath(): string;
 }
 
-export interface PrepareTestEnvParams extends TestEnv {
+export interface PrepareTestEnvParams extends Omit<TestEnv, 'cliConfigPath'> {
   readonly platformsToInstall?: readonly string[];
   readonly additionalUrls?: readonly string[];
 }
@@ -88,35 +96,39 @@ async function prepareWithCli(params: PrepareTestEnvParams): Promise<void> {
   log('Preparing test env with CLI');
   const cliExec = (args: string[], cliConfigPath?: string) =>
     __tests__.cliExec(params.cliPath, args, cliConfigPath);
-  const { cliConfigPath, dataDirPath, userDirPath, additionalUrls } = params;
-  await fs.mkdir(path.dirname(cliConfigPath), { recursive: true });
-  await Promise.all([
-    await cliExec([
-      'config',
-      'init',
-      '--dest-file',
-      cliConfigPath,
-      '--overwrite',
-    ]),
-    await fs.mkdir(dataDirPath, { recursive: true }),
-    await fs.mkdir(userDirPath, { recursive: true }),
-  ]);
-  await cliExec(
-    ['config', 'set', 'directories.user', userDirPath],
-    cliConfigPath
-  );
-  await cliExec(
-    ['config', 'set', 'directories.data', dataDirPath],
-    cliConfigPath
-  );
-  if (additionalUrls) {
+  const { cliConfigPaths, dataDirPath, userDirPath, additionalUrls } = params;
+  for (const [locale, cliConfigPath] of Object.entries(cliConfigPaths)) {
+    await fs.mkdir(path.dirname(cliConfigPath), { recursive: true });
+    await Promise.all([
+      await cliExec([
+        'config',
+        'init',
+        '--dest-file',
+        cliConfigPath,
+        '--overwrite',
+      ]),
+      await fs.mkdir(dataDirPath, { recursive: true }),
+      await fs.mkdir(userDirPath, { recursive: true }),
+    ]);
+    await cliExec(
+      ['config', 'set', 'directories.user', userDirPath],
+      cliConfigPath
+    );
     await cliExec(
-      ['config', 'set', 'board_manager.additional_urls', ...additionalUrls],
+      ['config', 'set', 'directories.data', dataDirPath],
       cliConfigPath
     );
+    if (additionalUrls) {
+      await cliExec(
+        ['config', 'set', 'board_manager.additional_urls', ...additionalUrls],
+        cliConfigPath
+      );
+    }
+    await cliExec(['config', 'set', 'locale', locale], cliConfigPath);
+    const config = await cliExec(['config', 'dump'], cliConfigPath);
+    log(`Using CLI config (locale: ${locale}): ${JSON.stringify(config)}`);
   }
-  const config = await cliExec(['config', 'dump'], cliConfigPath);
-  log(`Using CLI config: ${JSON.stringify(config)}`);
+  const cliConfigPath = cliConfigPaths['en'];
   await cliExec(['core', 'update-index'], cliConfigPath);
   log('Updated index');
   for (const platform of params.platformsToInstall ?? []) {