fix: update integ tests pointing to old namespace field

Author: nborges-aws

e2e-tests/fixtures/import/setup_memory_full.py

@@ -31,7 +31,7 @@ def main():
                 "semanticMemoryStrategy": {
                     "name": "bugbash_semantic",
                     "description": "Semantic strategy for bugbash testing",
-                    "namespaces": ["default"],
+                    "namespaceTemplates": ["default"],
                 }
             },
             {
@@ -68,7 +68,7 @@ def main():
     print(f"  eventExpiryDuration: 30")
     print(f"  executionRoleArn: {role_arn}")
     print("  strategies:")
-    print("    - type: SEMANTIC, name: bugbash_semantic, namespaces: [default]")
+    print("    - type: SEMANTIC, name: bugbash_semantic, namespaceTemplates: [default]")
     print("    - type: SUMMARIZATION, name: bugbash_summary")
     print("    - type: USER_PREFERENCE, name: bugbash_userpref")
     print("  tags: {env: bugbash, team: agentcore-cli}")

integ-tests/add-remove-resources.test.ts

@@ -44,7 +44,7 @@ describe('integration: add and remove resources', () => {
       telemetry.assertMetricEmitted({ command: 'add.memory', exit_reason: 'success' });
     });
 
-    it('adds a memory with EPISODIC strategy and verifies reflectionNamespaces', async () => {
+    it('adds a memory with EPISODIC strategy and verifies reflectionNamespaceTemplates', async () => {
       const episodicMemName = `EpiMem${Date.now().toString().slice(-6)}`;
       const result = await runCLI(
         ['add', 'memory', '--name', episodicMemName, '--strategies', 'EPISODIC', '--json'],
@@ -56,19 +56,19 @@ describe('integration: add and remove resources', () => {
       const json = JSON.parse(result.stdout);
       expect(json.success).toBe(true);
 
-      // Verify EPISODIC in config with reflectionNamespaces
+      // Verify EPISODIC in config with reflectionNamespaceTemplates
       const config = await readProjectConfig(project.projectPath);
       const memories = config.memories as {
         name: string;
-        strategies: { type: string; reflectionNamespaces?: string[] }[];
+        strategies: { type: string; reflectionNamespaceTemplates?: string[] }[];
       }[];
       const mem = memories.find(m => m.name === episodicMemName);
       expect(mem, 'Memory should exist').toBeTruthy();
 
       const episodic = mem!.strategies.find(s => s.type === 'EPISODIC');
       expect(episodic, 'EPISODIC strategy should exist').toBeTruthy();
-      expect(episodic!.reflectionNamespaces, 'Should have reflectionNamespaces').toBeDefined();
-      expect(episodic!.reflectionNamespaces!.length).toBeGreaterThan(0);
+      expect(episodic!.reflectionNamespaceTemplates, 'Should have reflectionNamespaceTemplates').toBeDefined();
+      expect(episodic!.reflectionNamespaceTemplates!.length).toBeGreaterThan(0);
 
       telemetry.assertMetricEmitted({
         command: 'add.memory',

integ-tests/create-memory.test.ts

@@ -80,7 +80,7 @@ describe.skipIf(!prereqs.npm || !prereqs.git)('integration: create with memory o
 
     // longAndShortTerm should have strategies defined
     const memory = memories![0]!;
-    const strategies = memory.strategies as { type: string; reflectionNamespaces?: string[] }[] | undefined;
+    const strategies = memory.strategies as { type: string; reflectionNamespaceTemplates?: string[] }[] | undefined;
     expect(strategies, 'memory should have strategies').toBeDefined();
     expect(strategies!.length).toBe(4);
 
@@ -91,10 +91,10 @@ describe.skipIf(!prereqs.npm || !prereqs.git)('integration: create with memory o
     expect(types).toContain('SUMMARIZATION');
     expect(types).toContain('EPISODIC');
 
-    // Verify EPISODIC has reflectionNamespaces
+    // Verify EPISODIC has reflectionNamespaceTemplates
     const episodic = strategies!.find(s => s.type === 'EPISODIC');
     expect(episodic, 'EPISODIC strategy should exist').toBeTruthy();
-    expect(episodic!.reflectionNamespaces, 'EPISODIC should have reflectionNamespaces').toBeDefined();
-    expect(episodic!.reflectionNamespaces!.length).toBeGreaterThan(0);
+    expect(episodic!.reflectionNamespaceTemplates, 'EPISODIC should have reflectionNamespaceTemplates').toBeDefined();
+    expect(episodic!.reflectionNamespaceTemplates!.length).toBeGreaterThan(0);
   });
 });

integ-tests/tui/add-memory-episodic.test.ts

@@ -3,15 +3,15 @@
  *
  * Drives the "Add Memory" wizard through the TUI to verify that when a user
  * selects the EPISODIC strategy, it is correctly persisted in agentcore.json
- * with both namespaces and reflectionNamespaces.
+ * with both namespaceTemplates and reflectionNamespaceTemplates.
  *
  * Exercises:
  *   - Navigation from HelpScreen -> Add Resource -> Memory
  *   - Memory name input
  *   - Expiry selection (default 30 days)
  *   - Strategy multi-select including EPISODIC
  *   - Confirm review screen
- *   - Verification that agentcore.json contains EPISODIC with reflectionNamespaces
+ *   - Verification that agentcore.json contains EPISODIC with reflectionNamespaceTemplates
  */
 import { TuiSession, WaitForTimeoutError } from '../../src/tui-harness/index.js';
 import { createMinimalProjectDir } from './helpers.js';
@@ -176,14 +176,14 @@ describe('Add Memory with EPISODIC Strategy', () => {
     expect(found).toBe(true);
   });
 
-  it('Step 9: agentcore.json contains EPISODIC with reflectionNamespaces', async () => {
+  it('Step 9: agentcore.json contains EPISODIC with reflectionNamespaceTemplates', async () => {
     const configPath = join(projectDir.dir, 'agentcore', 'agentcore.json');
     const raw = await readFileAsync(configPath, 'utf-8');
     const config = JSON.parse(raw);
 
     const memories = config.memories as {
       name: string;
-      strategies: { type: string; namespaces?: string[]; reflectionNamespaces?: string[] }[];
+      strategies: { type: string; namespaceTemplates?: string[]; reflectionNamespaceTemplates?: string[] }[];
     }[];
     expect(memories.length).toBeGreaterThan(0);
 
@@ -197,12 +197,12 @@ describe('Add Memory with EPISODIC Strategy', () => {
     expect(types).toContain('USER_PREFERENCE');
     expect(types).toContain('EPISODIC');
 
-    // Verify EPISODIC has namespaces AND reflectionNamespaces
+    // Verify EPISODIC has namespaceTemplates AND reflectionNamespaceTemplates
     const episodic = memory!.strategies.find(s => s.type === 'EPISODIC');
     expect(episodic, 'EPISODIC strategy should exist').toBeTruthy();
-    expect(episodic!.namespaces, 'EPISODIC should have namespaces').toBeDefined();
-    expect(episodic!.namespaces!.length).toBeGreaterThan(0);
-    expect(episodic!.reflectionNamespaces, 'EPISODIC should have reflectionNamespaces').toBeDefined();
-    expect(episodic!.reflectionNamespaces!.length).toBeGreaterThan(0);
+    expect(episodic!.namespaceTemplates, 'EPISODIC should have namespaceTemplates').toBeDefined();
+    expect(episodic!.namespaceTemplates!.length).toBeGreaterThan(0);
+    expect(episodic!.reflectionNamespaceTemplates, 'EPISODIC should have reflectionNamespaceTemplates').toBeDefined();
+    expect(episodic!.reflectionNamespaceTemplates!.length).toBeGreaterThan(0);
   });
 });