feat(toolbox-adk): Add e2e tests

packages/toolbox-adk/integration.cloudbuild.yaml

@@ -28,18 +28,18 @@ steps:
       - '-c'
       - corepack enable && pnpm --filter @toolbox-sdk/adk run test:unit
 
-  # - id: Run integration tests
-  #   name: 'node:${_VERSION}'
-  #   entrypoint: /bin/bash
-  #   waitFor: ['Install dependencies']
-  #   env:
-  #     - TOOLBOX_URL=$_TOOLBOX_URL
-  #     - TOOLBOX_VERSION=$_TOOLBOX_VERSION
-  #     - GOOGLE_CLOUD_PROJECT=$PROJECT_ID
-  #     - TOOLBOX_MANIFEST_VERSION=$_TOOLBOX_MANIFEST_VERSION
-  #   args:
-  #     - '-c'
-  #     - corepack enable && pnpm --filter @toolbox-sdk/adk run test:e2e
+  - id: Run integration tests
+    name: 'node:${_VERSION}'
+    entrypoint: /bin/bash
+    waitFor: ['Install dependencies']
+    env:
+      - TOOLBOX_URL=$_TOOLBOX_URL
+      - TOOLBOX_VERSION=$_TOOLBOX_VERSION
+      - GOOGLE_CLOUD_PROJECT=$PROJECT_ID
+      - TOOLBOX_MANIFEST_VERSION=$_TOOLBOX_MANIFEST_VERSION
+    args:
+      - '-c'
+      - corepack enable && pnpm --filter @toolbox-sdk/adk run test:e2e
 
 options:
   logging: CLOUD_LOGGING_ONLY

packages/toolbox-adk/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@toolbox-sdk/adk",
-    "version": "0.0.1",
+    "version": "0.1.2",
     "type": "module",
     "description": "JavaScript ADK SDK for interacting with the Toolbox service",
     "license": "Apache-2.0",
@@ -41,7 +41,7 @@
         "compile:cjs": "tsc -p tsconfig.cjs.json",
         "prepare": "npm run compile",
         "test:unit": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --config jest.config.json",
-        "test:e2e": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --config jest.e2e.config.json --runInBand",
+        "test:e2e": "npx tsc -p tsconfig.test.json && cross-env NODE_OPTIONS=--experimental-vm-modules jest --config jest.e2e.config.json --runInBand",
         "coverage": "cross-env NODE_OPTIONS=--experimental-vm-modules jest --config jest.config.json --coverage"
     },
     "dependencies": {
@@ -51,9 +51,6 @@
         "@toolbox-sdk/core": "workspace:*",
         "axios": "^1.12.2",
         "openapi-types": "^12.1.3",
-        "openapi-types": "^12.1.3",
-        "@google/genai": "^1.14.0",
-        "@toolbox-sdk/core": "workspace:*",
         "zod": "^3.24.4"
     }
 }

packages/toolbox-adk/test/e2e/jest.globalSetup.ts

@@ -0,0 +1,168 @@
+// Copyright 2025 Google LLC
+//
+// Licensed 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
+//
+//      http://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 * as path from 'path';
+import fs from 'fs-extra';
+import {spawn} from 'child_process';
+import {fileURLToPath} from 'url';
+import {
+  getEnvVar,
+  accessSecretVersion,
+  createTmpFile,
+  downloadBlob,
+  getToolboxBinaryGcsPath,
+  delay,
+} from './utils.js';
+import {CustomGlobal} from './types.js';
+
+const TOOLBOX_BINARY_NAME = 'toolbox';
+const SERVER_READY_TIMEOUT_MS = 30000; // 30 seconds
+const SERVER_READY_POLL_INTERVAL_MS = 2000; // 2 seconds
+
+export default async function globalSetup(): Promise<void> {
+  console.log('\nJest Global Setup: Starting...');
+
+  try {
+    const projectId = getEnvVar('GOOGLE_CLOUD_PROJECT');
+    const toolboxVersion = getEnvVar('TOOLBOX_VERSION');
+    (globalThis as CustomGlobal).__GOOGLE_CLOUD_PROJECT__ = projectId;
+
+    // Fetch tools manifest and create temp file
+    const toolsManifest = await accessSecretVersion(
+      projectId,
+      'sdk_testing_tools',
+      getEnvVar('TOOLBOX_MANIFEST_VERSION'),
+    );
+    const toolsFilePath = await createTmpFile(toolsManifest);
+    (globalThis as CustomGlobal).__TOOLS_FILE_PATH__ = toolsFilePath;
+    console.log(`Tools manifest stored at: ${toolsFilePath}`);
+
+    // Download toolbox binary
+    const toolboxGcsPath = getToolboxBinaryGcsPath(toolboxVersion);
+
+    // Add these two lines to define __dirname
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+
+    const localToolboxPath = path.resolve(__dirname, TOOLBOX_BINARY_NAME);
+
+    console.log(
+      `Downloading toolbox binary from gs://genai-toolbox/${toolboxGcsPath} to ${localToolboxPath}...`,
+    );
+    await downloadBlob('genai-toolbox', toolboxGcsPath, localToolboxPath);
+    console.log('Toolbox binary downloaded successfully.');
+
+    // Make toolbox executable
+    await fs.chmod(localToolboxPath, 0o700);
+
+    // Start toolbox server
+    console.log('Starting toolbox server process...');
+    const serverProcess = spawn(
+      localToolboxPath,
+      ['--tools-file', toolsFilePath],
+      {
+        stdio: ['ignore', 'pipe', 'pipe'], // ignore stdin, pipe stdout/stderr
+      },
+    );
+
+    (globalThis as CustomGlobal).__TOOLBOX_SERVER_PROCESS__ = serverProcess;
+
+    serverProcess.stdout?.on('data', (data: Buffer) => {
+      console.log(`[ToolboxServer STDOUT]: ${data.toString().trim()}`);
+    });
+
+    serverProcess.stderr?.on('data', (data: Buffer) => {
+      console.error(`[ToolboxServer STDERR]: ${data.toString().trim()}`);
+    });
+
+    serverProcess.on('error', err => {
+      console.error('Toolbox server process error:', err);
+      throw new Error('Failed to start toolbox server process.');
+    });
+
+    serverProcess.on('exit', (code, signal) => {
+      console.log(
+        `Toolbox server process exited with code ${code}, signal ${signal}.`,
+      );
+      if (
+        (globalThis as CustomGlobal).__TOOLBOX_SERVER_PROCESS__ &&
+        !(globalThis as CustomGlobal).__SERVER_TEARDOWN_INITIATED__
+      ) {
+        console.error('Toolbox server exited prematurely during setup.');
+      }
+    });
+
+    // Wait for server to start (basic poll check)
+    let started = false;
+    const startTime = Date.now();
+    while (Date.now() - startTime < SERVER_READY_TIMEOUT_MS) {
+      if (
+        serverProcess.pid &&
+        !serverProcess.killed &&
+        serverProcess.exitCode === null
+      ) {
+        console.log(
+          'Toolbox server process appears to be running. Polling for stability...',
+        );
+        await delay(SERVER_READY_POLL_INTERVAL_MS * 2);
+        if (serverProcess.exitCode === null) {
+          console.log(
+            'Toolbox server started successfully (process is active).',
+          );
+          started = true;
+          break;
+        } else {
+          console.log('Toolbox server process exited after initial start.');
+          break;
+        }
+      }
+      await delay(SERVER_READY_POLL_INTERVAL_MS);
+      console.log('Checking if toolbox server is started...');
+    }
+
+    if (!started) {
+      if (serverProcess && !serverProcess.killed) {
+        serverProcess.kill('SIGTERM');
+      }
+      throw new Error(
+        `Toolbox server failed to start within ${SERVER_READY_TIMEOUT_MS / 1000} seconds.`,
+      );
+    }
+
+    console.log('Jest Global Setup: Completed successfully.');
+  } catch (error) {
+    console.error('Jest Global Setup Failed:', error);
+    // Attempt to kill server if it started partially
+    const serverProcess = (globalThis as CustomGlobal)
+      .__TOOLBOX_SERVER_PROCESS__;
+    if (serverProcess && !serverProcess.killed) {
+      console.log('Attempting to terminate partially started server...');
+      serverProcess.kill('SIGKILL');
+    }
+    // Clean up temp file if created
+    const toolsFilePath = (globalThis as CustomGlobal).__TOOLS_FILE_PATH__;
+    if (toolsFilePath) {
+      try {
+        await fs.remove(toolsFilePath);
+      } catch (e) {
+        console.error(
+          'Error removing temp tools file during setup failure:',
+          e,
+        );
+      }
+    }
+    (globalThis as CustomGlobal).__GOOGLE_CLOUD_PROJECT__ = undefined;
+    throw error;
+  }
+}

packages/toolbox-adk/test/e2e/jest.globalTeardown.ts

@@ -0,0 +1,86 @@
+// Copyright 2025 Google LLC
+//
+// Licensed 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
+//
+//      http://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 * as fs from 'fs-extra';
+import {CustomGlobal} from './types.js';
+
+const SERVER_TERMINATE_TIMEOUT_MS = 10000; // 10 seconds
+
+export default async function globalTeardown(): Promise<void> {
+  console.log('\nJest Global Teardown: Starting...');
+  (globalThis as CustomGlobal).__SERVER_TEARDOWN_INITIATED__ = true;
+
+  const customGlobal = globalThis as CustomGlobal;
+  const serverProcess = customGlobal.__TOOLBOX_SERVER_PROCESS__;
+  const toolsFilePath = customGlobal.__TOOLS_FILE_PATH__;
+
+  if (serverProcess && !serverProcess.killed) {
+    console.log('Stopping toolbox server process...');
+    serverProcess.kill('SIGTERM'); // Graceful termination
+
+    // Wait for the process to exit
+    const stopPromise = new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        if (!serverProcess.killed) {
+          console.warn(
+            'Toolbox server did not terminate gracefully, sending SIGKILL.',
+          );
+          serverProcess.kill('SIGKILL');
+        }
+        // Resolve even if SIGKILL is needed, as we want teardown to finish
+        resolve();
+      }, SERVER_TERMINATE_TIMEOUT_MS);
+
+      serverProcess.on('exit', (code, signal) => {
+        clearTimeout(timeout);
+        console.log(
+          `Toolbox server process exited with code ${code}, signal ${signal} during teardown.`,
+        );
+        resolve();
+      });
+      serverProcess.on('error', err => {
+        // Should not happen if already running
+        clearTimeout(timeout);
+        console.error('Error during server process termination:', err);
+        reject(err);
+      });
+    });
+
+    try {
+      await stopPromise;
+    } catch (error) {
+      console.error('Error while waiting for server to stop:', error);
+      if (!serverProcess.killed) serverProcess.kill('SIGKILL'); // Ensure it's killed
+    }
+  } else {
+    console.log('Toolbox server process was not running or already handled.');
+  }
+
+  if (toolsFilePath) {
+    try {
+      console.log(`Removing temporary tools file: ${toolsFilePath}`);
+      await fs.remove(toolsFilePath);
+    } catch (error) {
+      console.error(
+        `Failed to remove temporary tools file ${toolsFilePath}:`,
+        error,
+      );
+    }
+  }
+  customGlobal.__TOOLBOX_SERVER_PROCESS__ = undefined;
+  customGlobal.__TOOLS_FILE_PATH__ = undefined;
+  customGlobal.__GOOGLE_CLOUD_PROJECT__ = undefined;
+
+  console.log('Jest Global Teardown: Completed.');
+}