feat: extend e2e ui tests

Author: Radheshg04

tests/e2e/core/fixtures/base.fixture.ts

@@ -10,6 +10,11 @@ import { MCPRegistryPage } from '../../features/mcp-registry/pages/mcp-registry.
 import { PluginsPage } from '../../features/plugins/pages/plugins.page'
 import { ObservabilityPage } from '../../features/observability/pages/observability.page'
 import { ConfigSettingsPage } from '../../features/config/pages/config-settings.page'
+import { GovernancePage } from '../../features/governance/pages/governance.page'
+import { MCPAuthConfigPage } from '../../features/mcp-auth-config/pages/mcp-auth-config.page'
+import { MCPSettingsPage } from '../../features/mcp-settings/pages/mcp-settings.page'
+import { MCPToolGroupsPage } from '../../features/mcp-tool-groups/pages/mcp-tool-groups.page'
+import { ModelLimitsPage } from '../../features/model-limits/pages/model-limits.page'
 
 /**
  * Custom test fixtures type
@@ -27,6 +32,11 @@ type BifrostFixtures = {
   pluginsPage: PluginsPage
   observabilityPage: ObservabilityPage
   configSettingsPage: ConfigSettingsPage
+  governancePage: GovernancePage
+  modelLimitsPage: ModelLimitsPage
+  mcpSettingsPage: MCPSettingsPage
+  mcpToolGroupsPage: MCPToolGroupsPage
+  mcpAuthConfigPage: MCPAuthConfigPage
 }
 
 /**
@@ -88,6 +98,26 @@ export const test = base.extend<BifrostFixtures>({
   configSettingsPage: async ({ page }, use) => {
     await use(new ConfigSettingsPage(page))
   },
+
+  governancePage: async ({ page }, use) => {
+    await use(new GovernancePage(page))
+  },
+
+  modelLimitsPage: async ({ page }, use) => {
+    await use(new ModelLimitsPage(page))
+  },
+
+  mcpSettingsPage: async ({ page }, use) => {
+    await use(new MCPSettingsPage(page))
+  },
+
+  mcpToolGroupsPage: async ({ page }, use) => {
+    await use(new MCPToolGroupsPage(page))
+  },
+
+  mcpAuthConfigPage: async ({ page }, use) => {
+    await use(new MCPAuthConfigPage(page))
+  },
 })
 
 export { expect }

tests/e2e/features/config/config.spec.ts

@@ -42,6 +42,90 @@ test.describe('Config Settings', () => {
       await expect(configSettingsPage.saveBtn).toBeVisible()
       await expect(configSettingsPage.page.getByRole('heading', { name: /Pricing/i })).toBeVisible()
     })
+
+    test('should navigate to MCP settings', async ({ configSettingsPage }) => {
+      await configSettingsPage.goto('mcp-gateway')
+      await expect(configSettingsPage.page.getByTestId('mcp-settings-view')).toBeVisible()
+      await expect(configSettingsPage.page.getByLabel('Max Agent Depth')).toBeVisible()
+      await expect(configSettingsPage.page.getByLabel('Tool Execution Timeout (seconds)')).toBeVisible()
+    })
+  })
+
+  test.describe('MCP Settings', () => {
+    test('should display MCP settings form', async ({ configSettingsPage }) => {
+      await configSettingsPage.goto('mcp-gateway')
+
+      await expect(configSettingsPage.page.getByTestId('mcp-settings-view')).toBeVisible()
+      await expect(configSettingsPage.page.locator('#mcp-agent-depth')).toBeVisible()
+      await expect(configSettingsPage.page.locator('#mcp-tool-execution-timeout')).toBeVisible()
+      await expect(configSettingsPage.page.locator('#mcp-binding-level')).toBeVisible()
+    })
+
+    test('should have save button disabled when no changes', async ({ configSettingsPage }) => {
+      await configSettingsPage.goto('mcp-gateway')
+
+      const saveBtn = configSettingsPage.page.getByTestId('mcp-settings-save-btn')
+      await expect(saveBtn).toBeVisible()
+      await expect(saveBtn).toBeDisabled()
+    })
+  })
+
+  test.describe('Pricing Config', () => {
+    let originalPricingUrl: string
+
+    test.beforeEach(async ({ configSettingsPage }) => {
+      await configSettingsPage.goto('pricing-config')
+      originalPricingUrl = await configSettingsPage.pricingDatasheetUrlInput.inputValue()
+    })
+
+    test.afterEach(async ({ configSettingsPage }) => {
+      await configSettingsPage.goto('pricing-config')
+      await configSettingsPage.setPricingDatasheetUrl(originalPricingUrl)
+      const isSaveEnabled = await configSettingsPage.pricingSaveBtn.isDisabled().then((d) => !d)
+      if (isSaveEnabled) {
+        await configSettingsPage.savePricingConfig()
+        await configSettingsPage.dismissToasts()
+      }
+    })
+
+    test('should display pricing config view', async ({ configSettingsPage }) => {
+      await expect(configSettingsPage.pricingConfigView).toBeVisible()
+      await expect(configSettingsPage.pricingDatasheetUrlInput).toBeVisible()
+      await expect(configSettingsPage.pricingForceSyncBtn).toBeVisible()
+      await expect(configSettingsPage.pricingSaveBtn).toBeVisible()
+    })
+
+    test('should set and save datasheet URL', async ({ configSettingsPage }) => {
+      const testUrl = 'https://example.com/pricing.json'
+      await configSettingsPage.setPricingDatasheetUrl(testUrl)
+
+      const isSaveEnabled = await configSettingsPage.pricingSaveBtn.isDisabled().then((d) => !d)
+      if (!isSaveEnabled) {
+        test.skip(true, 'Save button disabled (no changes detected or RBAC)')
+        return
+      }
+
+      await configSettingsPage.savePricingConfig()
+      await configSettingsPage.dismissToasts()
+    })
+
+    test('should trigger force sync', async ({ configSettingsPage }) => {
+      const isForceSyncEnabled = await configSettingsPage.pricingForceSyncBtn.isDisabled().then((d) => !d)
+      if (!isForceSyncEnabled) {
+        test.skip(true, 'Force sync button disabled (RBAC or no datasheet URL)')
+        return
+      }
+
+      await configSettingsPage.triggerForceSync()
+      await configSettingsPage.dismissToasts()
+    })
+
+    test('should validate URL format', async ({ configSettingsPage }) => {
+      await configSettingsPage.pricingDatasheetUrlInput.fill('invalid-url-no-http')
+      await configSettingsPage.pricingSaveBtn.click()
+
+      await expect(configSettingsPage.page.getByText(/URL must start with http|valid URL/i)).toBeVisible()
+    })
   })
 
   test.describe('Client Settings', () => {
@@ -67,6 +151,15 @@ test.describe('Config Settings', () => {
       await expect(configSettingsPage.disableDBPingsSwitch).toBeVisible()
     })
 
+    test('should display async job result TTL input when available', async ({ configSettingsPage }) => {
+      const isVisible = await configSettingsPage.asyncJobResultTtlInput.isVisible().catch(() => false)
+      if (isVisible) {
+        await expect(configSettingsPage.asyncJobResultTtlInput).toBeVisible()
+      } else {
+        test.skip(true, 'Async job result TTL not available')
+      }
+    })
+
     test('should toggle drop excess requests', async ({ configSettingsPage }) => {
       const initialState = await configSettingsPage.getSwitchState(configSettingsPage.dropExcessRequestsSwitch)
 
@@ -164,6 +257,15 @@ test.describe('Config Settings', () => {
       await expect(configSettingsPage.page.getByText(/Log Retention/i)).toBeVisible()
     })
 
+    test('should display workspace logging headers textarea when available', async ({ configSettingsPage }) => {
+      const isVisible = await configSettingsPage.workspaceLoggingHeadersTextarea.isVisible().catch(() => false)
+      if (isVisible) {
+        await expect(configSettingsPage.workspaceLoggingHeadersTextarea).toBeVisible()
+      } else {
+        test.skip(true, 'Workspace logging headers not available (depends on log connector)')
+      }
+    })
+
     test('should toggle content logging when available', async ({ configSettingsPage }) => {
       // Check if the switch is available (depends on logs being connected)
       const disableContentLoggingVisible = await configSettingsPage.disableContentLoggingSwitch.isVisible().catch(() => false)
@@ -272,9 +374,42 @@ test.describe('Config Settings', () => {
       await expect(configSettingsPage.saveBtn).toBeVisible()
     })
 
+    test('should display enforce auth on inference switch', async ({ configSettingsPage }) => {
+      const isVisible = await configSettingsPage.enforceAuthOnInferenceSwitch.isVisible().catch(() => false)
+      if (!isVisible) {
+        test.skip(true, 'Enforce auth on inference not available')
+        return
+      }
+      await expect(configSettingsPage.enforceAuthOnInferenceSwitch).toBeVisible()
+    })
+
+    test('should toggle enforce auth on inference', async ({ configSettingsPage }) => {
+      const isVisible = await configSettingsPage.enforceAuthOnInferenceSwitch.isVisible().catch(() => false)
+      if (!isVisible) {
+        test.skip(true, 'Enforce auth on inference not available')
+        return
+      }
+      const initialState = await configSettingsPage.getSwitchState(configSettingsPage.enforceAuthOnInferenceSwitch)
+      await configSettingsPage.toggleEnforceAuthOnInference()
+      const newState = await configSettingsPage.getSwitchState(configSettingsPage.enforceAuthOnInferenceSwitch)
+      expect(newState).toBe(!initialState)
+      await configSettingsPage.toggleEnforceAuthOnInference()
+      if (await configSettingsPage.hasPendingChanges()) {
+        await configSettingsPage.saveSettings()
+      }
+    })
+
+    test('should display required headers textarea', async ({ configSettingsPage }) => {
+      const isVisible = await configSettingsPage.requiredHeadersTextarea.isVisible().catch(() => false)
+      if (!isVisible) {
+        test.skip(true, 'Required headers control not available')
+        return
+      }
+      await expect(configSettingsPage.requiredHeadersTextarea).toBeVisible()
+    })
+
     test('should display rate limiting section', async ({ configSettingsPage }) => {
       const isVisible = await configSettingsPage.isRateLimitingSectionVisible()
-      // Rate limiting section should exist
       expect(isVisible).toBeDefined()
     })
   })

tests/e2e/features/config/pages/config-settings.page.ts

@@ -18,14 +18,18 @@ export class ConfigSettingsPage extends BasePage {
   readonly dropExcessRequestsSwitch: Locator
   readonly enableLiteLLMFallbacksSwitch: Locator
   readonly disableDBPingsSwitch: Locator
+  readonly asyncJobResultTtlInput: Locator
 
   // Logging Settings
   readonly enableLoggingSwitch: Locator
   readonly disableContentLoggingSwitch: Locator
   readonly logRetentionDaysInput: Locator
+  readonly workspaceLoggingHeadersTextarea: Locator
 
   // Security Settings
   readonly rateLimitingSection: Locator
+  readonly enforceAuthOnInferenceSwitch: Locator
+  readonly requiredHeadersTextarea: Locator
 
   // Performance Tuning Settings
   readonly workerPoolSizeInput: Locator
@@ -34,6 +38,12 @@ export class ConfigSettingsPage extends BasePage {
   // Observability Settings
   readonly observabilityToggles: Locator
 
+  // Pricing Config
+  readonly pricingConfigView: Locator
+  readonly pricingDatasheetUrlInput: Locator
+  readonly pricingForceSyncBtn: Locator
+  readonly pricingSaveBtn: Locator
+
   constructor(page: Page) {
     super(page)
     this.saveBtn = page.getByRole('button', { name: /Save/i })
@@ -42,23 +52,33 @@ export class ConfigSettingsPage extends BasePage {
     this.dropExcessRequestsSwitch = page.locator('#drop-excess-requests')
     this.enableLiteLLMFallbacksSwitch = page.locator('#enable-litellm-fallbacks')
     this.disableDBPingsSwitch = page.locator('#disable-db-pings-in-health')
+    this.asyncJobResultTtlInput = page.getByTestId('client-settings-async-job-result-ttl-input')
 
     // Logging Settings locators
     this.enableLoggingSwitch = page.locator('#enable-logging')
     this.disableContentLoggingSwitch = page.locator('#disable-content-logging')
     this.logRetentionDaysInput = page.getByLabel(/Log Retention Days/i).or(
       page.locator('#log-n-days')
     )
+    this.workspaceLoggingHeadersTextarea = page.getByTestId('workspace-logging-headers-textarea')
 
     // Security Settings locators
     this.rateLimitingSection = page.locator('text=Rate Limiting').locator('..')
+    this.enforceAuthOnInferenceSwitch = page.getByTestId('enforce-auth-on-inference-switch')
+    this.requiredHeadersTextarea = page.getByTestId('required-headers-textarea')
 
     // Performance Tuning locators
     this.workerPoolSizeInput = page.getByLabel(/Worker Pool Size/i)
     this.maxRequestBodySizeInput = page.getByLabel(/Max Request Body Size/i)
 
     // Observability locators
     this.observabilityToggles = page.locator('button[role="switch"]')
+
+    // Pricing Config locators
+    this.pricingConfigView = page.getByTestId('pricing-config-view')
+    this.pricingDatasheetUrlInput = page.getByTestId('pricing-datasheet-url-input')
+    this.pricingForceSyncBtn = page.getByTestId('pricing-force-sync-btn')
+    this.pricingSaveBtn = page.getByTestId('pricing-save-btn')
   }
 
   async goto(path: string): Promise<void> {
@@ -258,6 +278,25 @@ export class ConfigSettingsPage extends BasePage {
     return await this.page.getByText(/Rate Limiting/i).isVisible()
   }
 
+  async toggleEnforceAuthOnInference(): Promise<void> {
+    await this.enforceAuthOnInferenceSwitch.click()
+  }
+
+  async setRequiredHeaders(value: string): Promise<void> {
+    await this.requiredHeadersTextarea.clear()
+    await this.requiredHeadersTextarea.fill(value)
+  }
+
+  async setWorkspaceLoggingHeaders(value: string): Promise<void> {
+    await this.workspaceLoggingHeadersTextarea.clear()
+    await this.workspaceLoggingHeadersTextarea.fill(value)
+  }
+
+  async setAsyncJobResultTtl(value: string): Promise<void> {
+    await this.asyncJobResultTtlInput.clear()
+    await this.asyncJobResultTtlInput.fill(value)
+  }
+
   // === Observability Settings Methods ===
 
   async getObservabilityConnectors(): Promise<string[]> {
@@ -278,4 +317,21 @@ export class ConfigSettingsPage extends BasePage {
     const toggleSwitch = connectorSection.locator('button[role="switch"]').first()
     await toggleSwitch.click()
   }
+
+  // === Pricing Config Methods ===
+
+  async setPricingDatasheetUrl(url: string): Promise<void> {
+    await this.pricingDatasheetUrlInput.clear()
+    await this.pricingDatasheetUrlInput.fill(url)
+  }
+
+  async triggerForceSync(): Promise<void> {
+    await this.pricingForceSyncBtn.click()
+    await this.waitForSuccessToast()
+  }
+
+  async savePricingConfig(): Promise<void> {
+    await this.pricingSaveBtn.click()
+    await this.waitForSuccessToast()
+  }
 }

tests/e2e/features/dashboard/dashboard.spec.ts

@@ -211,14 +211,11 @@ test.describe('Dashboard', () => {
       await waitForNetworkIdle(dashboardPage.page)
       await dashboardPage.waitForChartsToLoad()
 
-      // Verify page loaded with correct state
+      // Verify page loaded with correct state from URL
       const url = dashboardPage.page.url()
       expect(url).toContain('period=7d')
-      // Chart state may be in URL or DOM - check both
-      const hasChartInUrl = url.includes('volume_chart=')
-      const toggleState = await dashboardPage.getChartToggleState(dashboardPage.volumeChartToggle)
-      // Either URL contains chart state OR DOM has toggle state
-      expect(hasChartInUrl || toggleState).toBeTruthy()
+      // volume_chart=line was in the URL - verify it persisted or chart rendered
+      expect(url).toMatch(/volume_chart=/)
     })
   })
 
@@ -233,14 +230,17 @@ test.describe('Dashboard', () => {
       const costChartContent = dashboardPage.costChart.locator('canvas, svg')
       const modelChartContent = dashboardPage.modelUsageChart.locator('canvas, svg')
 
-      // At least one of these should be visible (depends on data availability)
-      const hasVolumeChart = await volumeChartContent.count() > 0
-      const hasTokenChart = await tokenChartContent.count() > 0
-      const hasCostChart = await costChartContent.count() > 0
-      const hasModelChart = await modelChartContent.count() > 0
-
-      // All charts should have rendered content
-      expect(hasVolumeChart || hasTokenChart || hasCostChart || hasModelChart).toBe(true)
+      // Each chart card should have canvas or SVG content (chart library renders into these)
+      const volumeCount = await volumeChartContent.count()
+      const tokenCount = await tokenChartContent.count()
+      const costCount = await costChartContent.count()
+      const modelCount = await modelChartContent.count()
+
+      // All four chart cards should have rendered content (count > 0)
+      expect(volumeCount).toBeGreaterThan(0)
+      expect(tokenCount).toBeGreaterThan(0)
+      expect(costCount).toBeGreaterThan(0)
+      expect(modelCount).toBeGreaterThan(0)
     })
 
     test('should show chart legends', async ({ dashboardPage }) => {

tests/e2e/features/governance/governance.data.ts

@@ -0,0 +1,19 @@
+import { CustomerConfig, TeamConfig } from './pages/governance.page'
+
+export function createTeamData(overrides: Partial<TeamConfig> = {}): TeamConfig {
+  const timestamp = Date.now()
+  return {
+    name: `E2E Team ${timestamp}`,
+    budget: { maxLimit: 100, resetDuration: '1M' },
+    ...overrides,
+  }
+}
+
+export function createCustomerData(overrides: Partial<CustomerConfig> = {}): CustomerConfig {
+  const timestamp = Date.now()
+  return {
+    name: `E2E Customer ${timestamp}`,
+    budget: { maxLimit: 50, resetDuration: '1d' },
+    ...overrides,
+  }
+}