test(e2e): extend Anaconda AI CLI coverage and bump playwright-utils (#115)

Add version command coverage, refine server lifecycle steps, and update
@anaconda/playwright-utils to 1.3.6 with lockfile refresh.

Made-with: Cursor

Co-authored-by: izaheen@anaconda.com <izaheen@192.168.1.21>

Author: inhaz1

package-lock.json

@@ -10,7 +10,7 @@
     "cli"
   ],
   "devDependencies": {
-    "@anaconda/playwright-utils": "1.2.4",
+    "@anaconda/playwright-utils": "1.3.6",
     "@playwright/test": "^1.49.0",
     "cross-env": "^7.0.3",
     "dotenv": "^16.4.5",

package.json

@@ -4,7 +4,7 @@ import { AnacondaAiCli } from '@pages/cli/anaconda-ai-cmds';
 export const test = baseTest.extend<{
   anacondaAiCli: AnacondaAiCli;
 }>({
-  anacondaAiCli: async ({ }, use) => {
+  anacondaAiCli: async ({}, use) => {
     await use(new AnacondaAiCli());
   },
 });

tests/e2e/fixtures/fixture.ts

@@ -1,4 +1,4 @@
-import { shellCommand, stripAnsiSgrAndTrim, verifyShellExitCode, type ShellResult } from 'tests/utils/CliUtils';
+import { type ShellResult, shellCommand, stripAnsiSgrAndTrim, verifyShellExitCode } from 'tests/utils/CliUtils';
 import * as cliCommands from './cliCommands';
 import { expect } from 'tests/test-setup/page-setup';
 import { INVALID_MODEL_ERROR_MESSAGE, ModelApi, ServerApi } from '@testdata/model-api';
@@ -26,10 +26,7 @@ export class AnacondaAiCli {
     verifyShellExitCode(result, 'anaconda ai models --json');
 
     const models = JSON.parse(stripAnsiSgrAndTrim(result.output)) as ModelApi[];
-    expect(
-      Array.isArray(models) && models.length,
-      'models output should be a non-empty array',
-    ).toBeGreaterThan(0);
+    expect(Array.isArray(models) && models.length, 'models output should be a non-empty array').toBeGreaterThan(0);
     this.assertModelResponseData(models);
   }
 
@@ -59,7 +56,7 @@ export class AnacondaAiCli {
 
     const servers = JSON.parse(stripAnsiSgrAndTrim(result.output)) as ServerApi[];
     const expectedModelFile = `${modelName}_${modelQuantization}.gguf`;
-    const server = servers.find((s) => s.model === expectedModelFile);
+    const server = servers.find(s => s.model === expectedModelFile);
 
     expect(server, `Expected server for model "${expectedModelFile}" to appear in servers list`).toBeDefined();
     expect(server!.server_id, `Expected server_id to contain model name "${modelName}"`).toContain(modelName);
@@ -90,10 +87,9 @@ export class AnacondaAiCli {
   }
 
   public verifyInvalidDownloadModelCommand(result: ShellResult): void {
-    expect(
-      result.exitCode,
-      `Expected invalid download command to fail, but got exit code ${result.exitCode}`,
-    ).not.toBe(0);
+    expect(result.exitCode, `Expected invalid download command to fail, but got exit code ${result.exitCode}`).not.toBe(
+      0,
+    );
     const output = stripAnsiSgrAndTrim(result.output).toLowerCase();
     expect(output, 'Expected the model to be invalid').toContain('error');
     expect(output, 'Expected output should contain invalid model error message').toContain(INVALID_MODEL_ERROR_MESSAGE);
@@ -122,10 +118,7 @@ export class AnacondaAiCli {
     const output = stripAnsiSgrAndTrim(result.output).toLowerCase();
     const expectedModelFile = `${modelName}_${modelQuantization}.gguf`.toLowerCase();
     expect(output.includes('running'), 'Expected status to be "running"').toBeTruthy();
-    expect(
-      output.includes('inference/serve/'),
-      'Expected "inference/serve/" is running',
-    ).toBeTruthy();
+    expect(output.includes('inference/serve/'), 'Expected "inference/serve/" is running').toBeTruthy();
     expect(
       output.includes(expectedModelFile),
       `Expected model "${expectedModelFile}" to appear in output`,
@@ -202,11 +195,34 @@ export class AnacondaAiCli {
       expect(model.trained_for, `models[${modelIndex}].trained_for should be defined`).toBeDefined();
 
       model.quantizations.forEach((quant, quantIndex) => {
-        expect(quant.method, `models[${modelIndex}].quantizations[${quantIndex}].method should be defined`).toBeDefined();
-        expect(quant.running, `models[${modelIndex}].quantizations[${quantIndex}].running should be defined`).not.toBeUndefined();
-        expect(quant.downloaded, `models[${modelIndex}].quantizations[${quantIndex}].downloaded should be defined`).not.toBeUndefined();
-        expect(quant.blocked, `models[${modelIndex}].quantizations[${quantIndex}].blocked should be defined`).not.toBeUndefined();
+        expect(
+          quant.method,
+          `models[${modelIndex}].quantizations[${quantIndex}].method should be defined`,
+        ).toBeDefined();
+        expect(
+          quant.running,
+          `models[${modelIndex}].quantizations[${quantIndex}].running should be defined`,
+        ).toBeDefined();
+        expect(
+          quant.downloaded,
+          `models[${modelIndex}].quantizations[${quantIndex}].downloaded should be defined`,
+        ).toBeDefined();
+        expect(
+          quant.blocked,
+          `models[${modelIndex}].quantizations[${quantIndex}].blocked should be defined`,
+        ).toBeDefined();
       });
     });
   }
+
+  public async runAnacondaAiVersionCommand(): Promise<ShellResult> {
+    return await shellCommand(cliCommands.anacondaAiVersionCmd);
+  }
+
+  public verifyAnacondaAiVersionCommand(result: ShellResult): void {
+    verifyShellExitCode(result, 'anaconda ai --version');
+
+    const output = stripAnsiSgrAndTrim(result.output).toLowerCase();
+    expect(output.includes('anaconda-ai'), 'Expected "anaconda-ai" to be in output').toBeTruthy();
+  }
 }

tests/e2e/pages/cli/anaconda-ai-cmds.ts

@@ -1,5 +1,5 @@
 import { expect } from '@playwright/test';
-import { shellCommand, verifyShellExitCode, type ShellResult } from 'tests/utils/CliUtils';
+import { type ShellResult, shellCommand, verifyShellExitCode } from 'tests/utils/CliUtils';
 
 import * as cliCommands from './cliCommands';
 
@@ -12,8 +12,7 @@ export class AnacondaAiSetupCli {
   public verifyInstallAiPackageCommand(result: ShellResult): void {
     verifyShellExitCode(result, 'install command');
     const output = result.output.toLowerCase();
-    const isInstalledNow =
-      output.includes('executing transaction') && output.includes('anaconda-ai');
+    const isInstalledNow = output.includes('executing transaction') && output.includes('anaconda-ai');
     const isAlreadyInstalled = output.includes('all requested packages already installed');
 
     expect(
@@ -38,7 +37,7 @@ export class AnacondaAiSetupCli {
     verifyShellExitCode(result, 'sites list command');
   }
 
-  // True if `anaconda sites list` output contains the given site name. 
+  // True if `anaconda sites list` output contains the given site name.
   public isSiteNameListed(listResult: ShellResult, name: string): boolean {
     const output = `${listResult.output}\n${listResult.stderrOutput}`;
     return output.includes(`│ ${name} `);

tests/e2e/pages/cli/anaconda-ai-setup.ts

@@ -4,11 +4,9 @@ const anacondaAiChannel = process.env.ANACONDA_AI_CHANNEL ?? 'anaconda-cloud/lab
 const anacondaAiVersion = process.env.ANACONDA_AI_VERSION ?? '0.5.0';
 
 // Run all command in the anaconda-cli environment
-const condaRun = (inner: string): string =>
-  `conda run -n anaconda-cli --no-capture-output ${inner}`;
+const condaRun = (inner: string): string => `conda run -n anaconda-cli --no-capture-output ${inner}`;
 
-export const installAiPackageCmd =
-  `conda create -c defaults -c conda-forge ${anacondaAiChannel}::anaconda-ai=${anacondaAiVersion} -n anaconda-cli --yes`;
+export const installAiPackageCmd = `conda create -c defaults -c conda-forge ${anacondaAiChannel}::anaconda-ai=${anacondaAiVersion} -n anaconda-cli --yes`;
 
 // Verify the Anaconda AI package environment is runnable
 export const activateAiPackageEnvCmd = condaRun('conda list anaconda-ai');
@@ -21,20 +19,19 @@ export const addSiteCmd = (domain: string, name: string): string =>
 export const modifySiteCmd = (domain: string, name: string): string =>
   condaRun(`anaconda sites modify --domain ${domain} --name ${name} --default --yes`);
 
-export const configureAiPackageEnvToUseSandboxCmd = condaRun(
-  'anaconda ai config --backend ai-catalyst --yes',
-);
+export const configureAiPackageEnvToUseSandboxCmd = condaRun('anaconda ai config --backend ai-catalyst --yes');
 
 export const authWhoamiCmd = condaRun('anaconda auth whoami');
 
 export const anacondaAiHelpCmd = condaRun('anaconda ai --help');
 
+// Anaconda AI Version Command
+export const anacondaAiVersionCmd = condaRun('anaconda ai version --json');
+
 // Anaconda AI Models Command
 export const anacondaAiModelsListCmd = condaRun('anaconda ai models --json');
 
-export const anacondaAiBlockedModelsListCmd = condaRun(
-  'anaconda ai models --show-blocked --json',
-);
+export const anacondaAiBlockedModelsListCmd = condaRun('anaconda ai models --show-blocked --json');
 
 // Download Model Command
 export const downloadModelCmd = (modelName: string, modelQuantization: string): string =>

tests/e2e/pages/cli/cliCommands.ts

@@ -7,6 +7,11 @@ import {
 } from '@testdata/model-api';
 
 test.describe('Anaconda AI CLI Commands @anaconda-ai', () => {
+  test('anaconda ai version command', async ({ anacondaAiCli }) => {
+    const result = await anacondaAiCli.runAnacondaAiVersionCommand();
+    anacondaAiCli.verifyAnacondaAiVersionCommand(result);
+  });
+
   test('anaconda ai --help', async ({ anacondaAiCli }) => {
     const result = await anacondaAiCli.runAnacondaAiHelpCommand();
     anacondaAiCli.verifyAnacondaAiHelpCommand(result);
@@ -31,10 +36,7 @@ test.describe('Anaconda AI CLI Commands @anaconda-ai', () => {
   });
 
   test('anaconda ai download invalid model command', async ({ anacondaAiCli }) => {
-    const result = await anacondaAiCli.runDownloadModelCommand(
-      INVALID_MODEL_NAME,
-      INVALID_MODEL_QUANTIZATION,
-    );
+    const result = await anacondaAiCli.runDownloadModelCommand(INVALID_MODEL_NAME, INVALID_MODEL_QUANTIZATION);
     anacondaAiCli.verifyInvalidDownloadModelCommand(result);
   });
 
@@ -44,57 +46,59 @@ test.describe('Anaconda AI CLI Commands @anaconda-ai', () => {
   });
 
   test('anaconda ai server lifecycle: launch, verify, stop, and delete a model server', async ({ anacondaAiCli }) => {
-    await test.step('step 1: launch model server and verify it is running', async () => {
+    await test.step('1: launch model server and verify it is running', async () => {
       const launchResult = await anacondaAiCli.runLaunchModelCommand(
         DOWNLOAD_TEST_MODEL_NAME,
         DOWNLOAD_TEST_MODEL_QUANTIZATION,
       );
       anacondaAiCli.verifyLaunchModelCommand(launchResult, DOWNLOAD_TEST_MODEL_NAME, DOWNLOAD_TEST_MODEL_QUANTIZATION);
     });
 
-    await test.step('step 2: verify server appears in servers list with status "running"', async () => {
+    await test.step('2: verify server appears in servers list with status "running"', async () => {
       const serversResult = await anacondaAiCli.runAnacondaAiServersListCommand();
-      anacondaAiCli.verifyRunningServerInList(serversResult, DOWNLOAD_TEST_MODEL_NAME, DOWNLOAD_TEST_MODEL_QUANTIZATION);
+      anacondaAiCli.verifyRunningServerInList(
+        serversResult,
+        DOWNLOAD_TEST_MODEL_NAME,
+        DOWNLOAD_TEST_MODEL_QUANTIZATION,
+      );
     });
 
-    await test.step('step 3: launching the same server again returns AnacondaAIException', async () => {
+    await test.step('3: launching the same server again returns AnacondaAIException', async () => {
       const duplicateResult = await anacondaAiCli.runLaunchModelCommand(
         DOWNLOAD_TEST_MODEL_NAME,
         DOWNLOAD_TEST_MODEL_QUANTIZATION,
       );
       anacondaAiCli.verifyDuplicateLaunchModelCommand(duplicateResult);
     });
 
-    await test.step('step 4: stop the model server and verify it is stopped', async () => {
+    await test.step('4: stop the model server and verify it is stopped', async () => {
       const stopResult = await anacondaAiCli.runStopModelCommand(
         DOWNLOAD_TEST_MODEL_NAME,
         DOWNLOAD_TEST_MODEL_QUANTIZATION,
       );
       anacondaAiCli.verifyStopModelCommand(stopResult, DOWNLOAD_TEST_MODEL_NAME, DOWNLOAD_TEST_MODEL_QUANTIZATION);
     });
 
-    await test.step('step 5: delete the model server and verify it is removed', async () => {
+    await test.step('5: delete the model server and verify it is removed', async () => {
       const deleteResult = await anacondaAiCli.runStopAndRemoveModelCommand(
         DOWNLOAD_TEST_MODEL_NAME,
         DOWNLOAD_TEST_MODEL_QUANTIZATION,
       );
-      anacondaAiCli.verifyStopAndRemoveModelCommand(deleteResult, DOWNLOAD_TEST_MODEL_NAME, DOWNLOAD_TEST_MODEL_QUANTIZATION);
+      anacondaAiCli.verifyStopAndRemoveModelCommand(
+        deleteResult,
+        DOWNLOAD_TEST_MODEL_NAME,
+        DOWNLOAD_TEST_MODEL_QUANTIZATION,
+      );
     });
   });
 
   test('anaconda ai launch - invalid format returns ValueError', async ({ anacondaAiCli }) => {
-    const result = await anacondaAiCli.runLaunchModelCommand(
-      INVALID_MODEL_NAME,
-      INVALID_MODEL_QUANTIZATION,
-    );
+    const result = await anacondaAiCli.runLaunchModelCommand(INVALID_MODEL_NAME, INVALID_MODEL_QUANTIZATION);
     anacondaAiCli.verifyLaunchModelInvalidFormatCommand(result);
   });
 
   test('anaconda ai launch - unknown model returns ModelNotFound', async ({ anacondaAiCli }) => {
-    const result = await anacondaAiCli.runLaunchModelCommand(
-      INVALID_MODEL_NAME,
-      DOWNLOAD_TEST_MODEL_QUANTIZATION,
-    );
+    const result = await anacondaAiCli.runLaunchModelCommand(INVALID_MODEL_NAME, DOWNLOAD_TEST_MODEL_QUANTIZATION);
     anacondaAiCli.verifyLaunchModelNotFoundCommand(result);
   });
 });

tests/e2e/specs/cli/anaconda-ai.spec.ts

@@ -3,10 +3,12 @@
  * Runs the Anaconda AI package install before any tests.
  */
 import { AnacondaAiSetupCli } from '../e2e/pages/cli/anaconda-ai-setup';
-import { baseDomain, SELF_HOSTED_SITE_NAME } from '@testdata/site-data';
+import { SELF_HOSTED_SITE_NAME, baseDomain } from '@testdata/site-data';
 
 async function setupAnacondaAi(cli: AnacondaAiSetupCli): Promise<void> {
-  console.log(`[Global Setup] Installing and verifying Anaconda AI in "anaconda-cli" (version: ${process.env.ANACONDA_AI_VERSION ?? 'not set'})`,);
+  console.log(
+    `[Global Setup] Installing and verifying Anaconda AI in "anaconda-cli" (version: ${process.env.ANACONDA_AI_VERSION ?? 'not set'})`,
+  );
 
   // Install the Anaconda AI package
   const installResult = await cli.runInstallAiPackageCommand();