chore: Add system tests for agent engines module

PiperOrigin-RevId: 895367197

Author: sararob

system_test/agent_engine_e2e_test.ts

@@ -9,10 +9,29 @@ import {Client} from '../src/genai/client';
 const PROJECT = process.env['GCLOUD_PROJECT'];
 const LOCATION = 'us-central1';
 
+async function pollOperation(client: Client, operationName: string) {
+  let isDone = false;
+  let pollCount = 0;
+  while (!isDone && pollCount < 40) {
+    const status = await client.agentEnginesInternal.getAgentOperationInternal({
+      operationName,
+    });
+    if (status.done) {
+      return status;
+    }
+    pollCount++;
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+  }
+  throw new Error(
+      `Operation ${operationName} did not complete within the timeout.`,
+  );
+}
+
 describe('agentEnginesInternal', () => {
   let client: Client;
   let agentEngineName: string|undefined;
-  let operationName: string|undefined;
+  let createOperationName: string|undefined;
+  let updateOperationName: string|undefined;
 
   beforeEach(() => {
     jasmine.DEFAULT_TIMEOUT_INTERVAL = 300000;
@@ -25,11 +44,11 @@ describe('agentEnginesInternal', () => {
   afterAll(async () => {
     // If the test failed during the create operation, try to recover
     // the resource name from the operation to cleanup.
-    if (!agentEngineName && operationName) {
+    if (!agentEngineName && createOperationName) {
       try {
         const status =
             await client.agentEnginesInternal.getAgentOperationInternal({
-              operationName,
+              operationName: createOperationName,
             });
         if (status.done && status.response?.name) {
           agentEngineName = status.response.name;
@@ -60,25 +79,42 @@ describe('agentEnginesInternal', () => {
     });
 
     expect(createOp.name).toBeDefined();
-    operationName = createOp.name;
-
-    // Poll for operation completion to get the Agent Engine resource name.
-    let isDone = false;
-    let pollCount = 0;
-    while (!isDone && pollCount < 40) {
-      const status =
-          await client.agentEnginesInternal.getAgentOperationInternal({
-            operationName: operationName!,
-          });
-      if (status.done) {
-        isDone = true;
-        agentEngineName = status.response?.name;
-      } else {
-        pollCount++;
-        await new Promise((resolve) => setTimeout(resolve, 5000));
-      }
-    }
+    createOperationName = createOp.name;
+
+    const status = await pollOperation(client, createOperationName!);
+    agentEngineName = status.response?.name;
 
     expect(agentEngineName).toBeDefined();
   });
+
+  it('should get an Agent Engine', async () => {
+    const agentEngine = await client.agentEnginesInternal.getInternal({
+      name: agentEngineName!,
+    });
+    expect(agentEngine.name).toBeDefined();
+    expect(agentEngine.displayName).toEqual('test-agent-engine-sample');
+    expect(agentEngine.labels).toEqual({'test-label': 'test-value'});
+  });
+
+  it('should update an Agent Engine', async () => {
+    const updateOp = await client.agentEnginesInternal.updateInternal({
+      name: agentEngineName!,
+      config: {
+        displayName: 'test-agent-engine-updated',
+        description: 'Updated from the Vertex JS SDK system tests',
+      },
+    });
+
+    expect(updateOp.name).toBeDefined();
+    updateOperationName = updateOp.name;
+
+    const status = await pollOperation(client, updateOperationName!);
+
+    if (status.response) {
+      expect(status.response.displayName)
+          .toEqual(
+              'test-agent-engine-updated',
+          );
+    }
+  });
 });

system_test/memories_e2e_test.ts

@@ -0,0 +1,110 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {Client} from '../src/genai/client';
+
+const PROJECT = process.env['GCLOUD_PROJECT'];
+const LOCATION = 'us-central1';
+
+async function pollOperation(client: Client, operationName: string) {
+  let isDone = false;
+  let pollCount = 0;
+  while (!isDone && pollCount < 40) {
+    const status = await client.agentEnginesInternal.getAgentOperationInternal({
+      operationName,
+    });
+    if (status.done) {
+      return status;
+    }
+    pollCount++;
+    await new Promise((resolve) => setTimeout(resolve, 5000));
+  }
+  throw new Error(
+      `Operation ${operationName} did not complete within the timeout.`,
+  );
+}
+
+describe('agentEnginesInternal.memories', () => {
+  let client: Client;
+  let agentEngineName: string|undefined;
+  let createOperationName: string|undefined;
+
+  const memoriesToCleanup: string[] = [];
+
+  beforeAll(async () => {
+    jasmine.DEFAULT_TIMEOUT_INTERVAL = 300000;
+
+    client = new Client({
+      project: PROJECT as string,
+      location: LOCATION,
+    });
+
+    // Create the Agent Engine and wait for it to be ready
+    const createOp = await client.agentEnginesInternal.createInternal({
+      config: {
+        displayName: 'agent-engine-memories-test',
+        description: 'Created from the Vertex JS SDK system tests',
+        labels: {'test-label': 'test-value'},
+      },
+    });
+
+    createOperationName = createOp.name;
+    const status = await pollOperation(client, createOperationName!);
+    agentEngineName = status.response?.name;
+  });
+
+  afterAll(async () => {
+    // Clean up any memories created during the tests
+    for (const memoryName of memoriesToCleanup) {
+      try {
+        await client.agentEnginesInternal.memories.delete({name: memoryName});
+      } catch (e) {
+        console.error(
+            `Failed to delete memory ${memoryName} during cleanup:`, e);
+      }
+    }
+
+    // Recover the Agent Engine name if the creation failed
+    if (!agentEngineName && createOperationName) {
+      try {
+        const status =
+            await client.agentEnginesInternal.getAgentOperationInternal({
+              operationName: createOperationName,
+            });
+        if (status.done && status.response?.name) {
+          agentEngineName = status.response.name;
+        }
+      } catch (e) {
+        console.error('Failed to recover Agent Engine name from operation:', e);
+      }
+    }
+
+    // Clean up the Agent Engine
+    if (agentEngineName) {
+      try {
+        await client.agentEnginesInternal.deleteInternal({
+          name: agentEngineName,
+        });
+      } catch (e) {
+        console.error('Failed to delete Agent Engine during cleanup:', e);
+      }
+    }
+  });
+
+  it('should create a memory in an agent engine', async () => {
+    const createOp = await client.agentEnginesInternal.memories.createInternal({
+      name: agentEngineName!,
+      fact: 'test-memory-fact',
+      scope: {'user_id': 'test-user-id'},
+    });
+
+    expect(createOp.name).toBeDefined();
+
+    if (createOp.name) {
+      memoriesToCleanup.push(createOp.name);
+    }
+  });
+});