@optimizely/ocp-cli 1.2.13 → 1.2.14-beta.0

package/src/test/e2e/__tests__/directory/directory.test.ts

@@ -0,0 +1,668 @@
+import { BaseE2ETest } from '../../lib/base-test';
+import { testData } from '../../config/test-data-helpers';
+
+class DirectoryE2ETest extends BaseE2ETest {
+  // Directory list commands
+  async runListCommand(appId?: string, options?: { allStatuses?: boolean; availability?: string; useShortFlags?: boolean }) {
+    const args = ['directory', 'list'];
+    if (appId) {
+      args.push(appId);
+    }
+    if (options?.allStatuses) {
+      args.push('--allStatuses');
+    }
+    if (options?.availability) {
+      // Test both short and long forms based on option
+      if (options.useShortFlags) {
+        args.push(`-a=${options.availability}`);
+      } else {
+        args.push(`--availability=${options.availability}`);
+      }
+    }
+    return this.execute(args);
+  }
+
+  async runInfoCommand(appId: string, availability?: string, useShortFlags?: boolean) {
+    const args = ['directory', 'info', appId];
+    if (availability) {
+      if (useShortFlags) {
+        args.push(`-a=${availability}`);
+      } else {
+        args.push(`--availability=${availability}`);
+      }
+    }
+    return this.execute(args);
+  }
+
+  async runStatusCommand(appId?: string, availability?: string, useShortFlags?: boolean) {
+    const args = ['directory', 'status'];
+    if (appId) {
+      args.push(appId);
+    }
+    if (availability) {
+      if (useShortFlags) {
+        args.push(`-a=${availability}`);
+      } else {
+        args.push(`--availability=${availability}`);
+      }
+    }
+    return this.execute(args);
+  }
+
+  async runListFunctionsCommand(appId: string, trackerId: string, availability?: string, useShortFlags?: boolean) {
+    const args = ['directory', 'list-functions', appId, trackerId];
+    if (availability) {
+      if (useShortFlags) {
+        args.push(`-a=${availability}`);
+      } else {
+        args.push(`--availability=${availability}`);
+      }
+    }
+    return this.execute(args);
+  }
+
+  async runListGlobalFunctionsCommand(appId: string, availability?: string, useShortFlags?: boolean) {
+    const args = ['directory', 'list-global-functions', appId];
+    if (availability) {
+      if (useShortFlags) {
+        args.push(`-a=${availability}`);
+      } else {
+        args.push(`--availability=${availability}`);
+      }
+    }
+    return this.execute(args);
+  }
+
+  async runListInstallsCommand(appVersion: string, availability?: string, useShortFlags?: boolean) {
+    const args = ['directory', 'list-installs', appVersion];
+    if (availability) {
+      if (useShortFlags) {
+        args.push(`-a=${availability}`);
+      } else {
+        args.push(`--availability=${availability}`);
+      }
+    }
+    return this.execute(args);
+  }
+
+  async runListSourceFunctionsCommand(appId: string, trackerId: string, availability?: string, useShortFlags?: boolean) {
+    const args = ['directory', 'list-source-functions', appId, trackerId];
+    if (availability) {
+      if (useShortFlags) {
+        args.push(`-a=${availability}`);
+      } else {
+        args.push(`--availability=${availability}`);
+      }
+    }
+    return this.execute(args);
+  }
+
+  // Public wrapper methods to access protected assertions
+  public checkSuccess(result: any) {
+    this.assertSuccess(result);
+  }
+
+  public checkFailure(result: any) {
+    this.assertFailure(result);
+  }
+
+  public checkOutputContains(result: any, text: string) {
+    this.assertOutputContains(result, text);
+  }
+
+  public checkOutputMatchesBaseline(result: any, baselinePath: string, maxLines?: number) {
+    this.assertOutputMatchesBaseline(result, baselinePath, maxLines);
+  }
+
+  public clearHistory() {
+    this.cliExecutor.clearProcessHistory();
+  }
+
+  public executePublic(args: string[], options?: any) {
+    return this.execute(args, options);
+  }
+}
+
+describe('Directory Commands E2E Tests', () => {
+  let testInstance: DirectoryE2ETest;
+
+  beforeAll(() => {
+    testInstance = new DirectoryE2ETest();
+  });
+
+  afterAll(async () => {
+    if (testInstance) {
+      await testInstance.cleanup();
+    }
+  });
+
+  afterEach(() => {
+    // Clean up process history after each test
+    if (testInstance) {
+      testInstance.clearHistory();
+    }
+  });
+
+  describe('directory list', () => {
+    it('should list all directory entries successfully', async () => {
+      const result = await testInstance.runListCommand();
+      
+      if (result.exitCode !== 0) {
+        // only allow failure if the user is not allowed to list all directory entries
+        expect(result.stderr).toContain('Could not authenticate');
+      } else {
+        // Check baseline format (first 6 lines only - header + 1 entry)
+        testInstance.checkOutputMatchesBaseline(result, 'directory/list.txt', 4);
+      }
+      
+    }, 15000);
+
+    it('should filter by specific app ID', async () => {
+      const result = await testInstance.runListCommand(testData.appId);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+      expect(result.stdout).toContain(testData.appId);
+    });
+
+    it('should include all statuses when flag is set', async () => {
+      const result = await testInstance.runListCommand(undefined, { allStatuses: true });
+      
+      // The command might succeed or fail depending on the data, but it should run
+      expect([0, 1]).toContain(result.exitCode);
+      if (result.exitCode === 0) {
+        expect(result.stdout).toBeTruthy();
+      }
+    });
+
+    it('should work with availability zone parameter', async () => {
+      const result = await testInstance.runListCommand(undefined, { availability: 'us' });
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (short form)', async () => {
+      const result = await testInstance.runListCommand(undefined, { availability: 'us', useShortFlags: true });
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (long form)', async () => {
+      const result = await testInstance.runListCommand(undefined, { availability: 'us', useShortFlags: false });
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with multiple flags (allStatuses + availability)', async () => {
+      const result = await testInstance.runListCommand(undefined, { allStatuses: true, availability: 'us' });
+      
+      // The command might succeed or fail depending on the data, but it should run
+      expect([0, 1]).toContain(result.exitCode);
+      if (result.exitCode === 0) {
+        expect(result.stdout).toBeTruthy();
+      }
+    });
+
+    it('should work with multiple flags using short form for availability', async () => {
+      const result = await testInstance.runListCommand(undefined, { allStatuses: true, availability: 'us', useShortFlags: true });
+      
+      // The command might succeed or fail depending on the data, but it should run
+      expect([0, 1]).toContain(result.exitCode);
+      if (result.exitCode === 0) {
+        expect(result.stdout).toBeTruthy();
+      }
+    });
+
+    it('should complete within reasonable time', async () => {
+      const result = await testInstance.runListCommand(testData.appId);
+      
+      expect(result.executionTime).toBeLessThan(15000); // 15 seconds
+      expect(result.timedOut).toBe(false);
+    });
+  });
+
+  describe('directory info', () => {
+    it('should return app information for valid app ID', async () => {
+      const result = await testInstance.runInfoCommand(testData.appId);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+      
+      // Check baseline format (first 12 lines only - header + General section + first version)
+      testInstance.checkOutputMatchesBaseline(result, 'directory/info.txt', 12);
+    }, 15000);
+
+    it('should work with availability zone parameter', async () => {
+      const result = await testInstance.runInfoCommand(testData.appId, 'us');
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (short form)', async () => {
+      const result = await testInstance.runInfoCommand(testData.appId, 'us', true);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (long form)', async () => {
+      const result = await testInstance.runInfoCommand(testData.appId, 'us', false);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should handle non-existent app ID gracefully', async () => {
+      const result = await testInstance.runInfoCommand('nonexistent-app-id');
+      
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toBeTruthy();
+    });
+
+    it('should fail when app ID parameter is missing', async () => {
+      const result = await testInstance.executePublic(['directory', 'info']);
+      
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toBeTruthy();
+    });
+  });
+
+  describe('directory status', () => {
+    it('should return status for valid app ID and version', async () => {
+      const result = await testInstance.runStatusCommand(testData.appVersionString);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+      
+      // Check for status information
+      expect(result.stdout).toContain('Version state:');
+    });
+
+    it('should work with availability zone parameter', async () => {
+      const result = await testInstance.runStatusCommand(testData.appVersionString, 'us');
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (short form)', async () => {
+      const result = await testInstance.runStatusCommand(testData.appVersionString, 'us', true);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (long form)', async () => {
+      const result = await testInstance.runStatusCommand(testData.appVersionString, 'us', false);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should fail when app ID and version are missing', async () => {
+      const result = await testInstance.runStatusCommand();
+      
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toBeTruthy();
+      // The error could be about missing app.yaml or missing parameters
+      expect(result.stderr).toMatch(/App ID and version are required|app manifest|app\.yaml/);
+    });
+
+    it('should handle invalid app version format', async () => {
+      const result = await testInstance.runStatusCommand('invalid-format');
+      
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toBeTruthy();
+    });
+  });
+
+  describe('directory list-functions', () => {
+    it('should list functions for valid app and tracker ID', async () => {
+      const result = await testInstance.runListFunctionsCommand(testData.appId, testData.trackerId);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter', async () => {
+      const result = await testInstance.runListFunctionsCommand(testData.appId, testData.trackerId, 'us');
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (short form)', async () => {
+      const result = await testInstance.runListFunctionsCommand(testData.appId, testData.trackerId, 'us', true);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (long form)', async () => {
+      const result = await testInstance.runListFunctionsCommand(testData.appId, testData.trackerId, 'us', false);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should fail when app ID parameter is missing', async () => {
+      const result = await testInstance.executePublic(['directory', 'list-functions']);
+      
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toBeTruthy();
+    });
+
+    it('should fail when tracker ID parameter is missing', async () => {
+      const result = await testInstance.executePublic(['directory', 'list-functions', testData.appId]);
+      
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toBeTruthy();
+    });
+
+    it('should handle non-existent app installation gracefully', async () => {
+      const result = await testInstance.runListFunctionsCommand('nonexistent-app', 'nonexistent-tracker');
+      
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toBeTruthy();
+    });
+  });
+
+  describe('directory list-global-functions', () => {
+    it('should list global functions for valid app ID', async () => {
+      const result = await testInstance.runListGlobalFunctionsCommand(testData.appId);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter', async () => {
+      const result = await testInstance.runListGlobalFunctionsCommand(testData.appId, 'us');
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (short form)', async () => {
+      const result = await testInstance.runListGlobalFunctionsCommand(testData.appId, 'us', true);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (long form)', async () => {
+      const result = await testInstance.runListGlobalFunctionsCommand(testData.appId, 'us', false);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should fail when app ID parameter is missing', async () => {
+      const result = await testInstance.executePublic(['directory', 'list-global-functions']);
+      
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toBeTruthy();
+    });
+
+    it('should handle non-existent app ID gracefully', async () => {
+      const result = await testInstance.runListGlobalFunctionsCommand('nonexistent-app-id');
+      
+      // The command may succeed with empty results or fail - both are acceptable
+      expect(result.exitCode).toBeDefined();
+      expect(result.stdout).toBeDefined();
+    });
+  });
+
+  describe('directory list-installs', () => {
+    it('should list installations for valid app version', async () => {
+      const result = await testInstance.runListInstallsCommand(testData.appVersionString);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+      
+      // Check for table headers - use the actual headers from output
+      expect(result.stdout).toMatch(/Tracker/);
+      expect(result.stdout).toContain('Created At');
+      expect(result.stdout).toContain('Updated At');
+    });
+
+    it('should list installations for app without version', async () => {
+      const result = await testInstance.runListInstallsCommand(testData.appId);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter', async () => {
+      const result = await testInstance.runListInstallsCommand(testData.appVersionString, 'us');
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (short form)', async () => {
+      const result = await testInstance.runListInstallsCommand(testData.appVersionString, 'us', true);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (long form)', async () => {
+      const result = await testInstance.runListInstallsCommand(testData.appVersionString, 'us', false);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should fail when app version parameter is missing', async () => {
+      const result = await testInstance.executePublic(['directory', 'list-installs']);
+      
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toBeTruthy();
+    });
+
+    it('should handle non-existent app gracefully', async () => {
+      const result = await testInstance.runListInstallsCommand('nonexistent-app@1.0.0');
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+      // Should return empty results or appropriate message
+    });
+  });
+
+  describe('directory list-source-functions', () => {
+    it('should list source functions for valid app and tracker ID', async () => {
+      const result = await testInstance.runListSourceFunctionsCommand(testData.appId, testData.trackerId);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter', async () => {
+      const result = await testInstance.runListSourceFunctionsCommand(testData.appId, testData.trackerId, 'us');
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (short form)', async () => {
+      const result = await testInstance.runListSourceFunctionsCommand(testData.appId, testData.trackerId, 'us', true);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should work with availability zone parameter (long form)', async () => {
+      const result = await testInstance.runListSourceFunctionsCommand(testData.appId, testData.trackerId, 'us', false);
+      
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBeTruthy();
+    });
+
+    it('should fail when app ID parameter is missing', async () => {
+      const result = await testInstance.executePublic(['directory', 'list-source-functions']);
+      
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toBeTruthy();
+    });
+
+    it('should fail when tracker ID parameter is missing', async () => {
+      const result = await testInstance.executePublic(['directory', 'list-source-functions', testData.appId]);
+      
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toBeTruthy();
+    });
+
+    it('should handle non-existent app installation gracefully', async () => {
+      const result = await testInstance.runListSourceFunctionsCommand('nonexistent-app', 'nonexistent-tracker');
+      
+      expect(result.exitCode).not.toBe(0);
+      expect(result.stderr).toBeTruthy();
+    });
+  });
+
+  describe('Flag Variations', () => {
+    describe('availability flag variations', () => {
+      it('should accept availability flag in various formats (short form with =)', async () => {
+        const result = await testInstance.executePublic(['directory', 'list', '-a=us']);
+        
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toBeTruthy();
+      });
+
+      it('should accept availability flag in various formats (long form with =)', async () => {
+        const result = await testInstance.executePublic(['directory', 'list', '--availability=us']);
+        
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toBeTruthy();
+      });
+    });
+
+    describe('allStatuses flag variations', () => {
+      it('should accept allStatuses flag (long form)', async () => {
+        const result = await testInstance.executePublic(['directory', 'list', '--allStatuses']);
+        
+        // The command might succeed or fail depending on the data, but it should run
+        expect([0, 1]).toContain(result.exitCode);
+      });
+
+      it('should work with combined flags (allStatuses + availability short form)', async () => {
+        const result = await testInstance.executePublic(['directory', 'list', '--allStatuses', '-a=us']);
+        
+        expect([0, 1]).toContain(result.exitCode);
+      });
+
+      it('should work with combined flags (allStatuses + availability long form)', async () => {
+        const result = await testInstance.executePublic(['directory', 'list', '--allStatuses', '--availability=us']);
+        
+        expect([0, 1]).toContain(result.exitCode);
+      });
+
+      it('should work with combined flags in different order', async () => {
+        const result = await testInstance.executePublic(['directory', 'list', '--availability=us', '--allStatuses']);
+        
+        expect([0, 1]).toContain(result.exitCode);
+      });
+    });
+
+    describe('flag validation and error handling', () => {
+      it('should handle invalid availability values gracefully', async () => {
+        const result = await testInstance.executePublic(['directory', 'list', '--availability=invalid']);
+        
+        // Should either succeed with default behavior or fail gracefully
+        expect(result.exitCode).toBeDefined();
+      });
+
+      it('should handle duplicate flags gracefully (last one wins)', async () => {
+        const result = await testInstance.executePublic(['directory', 'list', '--availability=eu', '--availability=us']);
+        
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toBeTruthy();
+      });
+
+      it('should handle mixed short and long forms of same flag', async () => {
+        const result = await testInstance.executePublic(['directory', 'list', '-a=eu', '--availability=us']);
+        
+        expect(result.exitCode).toBe(0);
+        expect(result.stdout).toBeTruthy();
+      });
+    });
+
+    describe('comprehensive flag testing across directory commands', () => {
+      it('should test info command with all flag variations', async () => {
+        const flagVariations = [
+          ['directory', 'info', testData.appId, '-a=us'],
+          ['directory', 'info', testData.appId, '--availability=us']
+        ];
+
+        for (const args of flagVariations) {
+          const result = await testInstance.executePublic(args);
+          expect(result.exitCode).toBe(0);
+          expect(result.stdout).toBeTruthy();
+        }
+      });
+
+      it('should test status command with all flag variations', async () => {
+        const flagVariations = [
+          ['directory', 'status', testData.appVersionString, '-a=us'],
+          ['directory', 'status', testData.appVersionString, '--availability=us']
+        ];
+
+        for (const args of flagVariations) {
+          const result = await testInstance.executePublic(args);
+          expect(result.exitCode).toBe(0);
+          expect(result.stdout).toBeTruthy();
+        }
+      });
+
+      it('should test list-installs command with all flag variations', async () => {
+        const flagVariations = [
+          ['directory', 'list-installs', testData.appVersionString, '-a=us'],
+          ['directory', 'list-installs', testData.appVersionString, '--availability=us']
+        ];
+
+        for (const args of flagVariations) {
+          const result = await testInstance.executePublic(args);
+          expect(result.exitCode).toBe(0);
+          expect(result.stdout).toBeTruthy();
+        }
+      });
+    });
+  });
+
+  describe('Error Scenarios', () => {
+    it('should handle malformed availability zone parameter', async () => {
+      const result = await testInstance.runListCommand(undefined, { availability: 'invalid-zone' });
+      
+      // The command might still succeed but with default zone behavior
+      // Or it might fail - depends on API validation
+      expect(result.exitCode).toBeDefined();
+    });
+  });
+
+  describe('Performance Tests', () => {
+    it('should complete directory list within reasonable time', async () => {
+      const result = await testInstance.runListCommand();
+      
+      expect(result.executionTime).toBeLessThan(20000); // 20 seconds
+      expect(result.executionTime).toBeGreaterThan(0);
+    }, 25000);
+
+    it('should complete directory info within reasonable time', async () => {
+      const result = await testInstance.runInfoCommand(testData.appId);
+      
+      expect(result.executionTime).toBeLessThan(10000); // 10 seconds
+      expect(result.timedOut).toBe(false);
+    }, 15000);
+
+    it('should complete function listings within reasonable time', async () => {
+      const result = await testInstance.runListGlobalFunctionsCommand(testData.appId);
+      
+      expect(result.executionTime).toBeLessThan(10000); // 10 seconds
+      expect(result.timedOut).toBe(false);
+    }, 15000);
+  });
+});