feat(feature-flags): add e2e tests and fix startup table creation

- Add Playwright e2e smoke tests (page load, table visibility)
- Add Playwright e2e flow tests (toggle flag, override CRUD, check
  endpoint, overrides dialog)
- Add page object for FeatureFlags manage page
- Fix FeatureFlagSyncService to create module tables at startup via
  CreateTablesAsync — prevents crash when module is added to an
  existing database that only has host tables

https://claude.ai/code/session_01Cfi9aG39WHwLr2cmsmPAnK

Author: claude

modules/FeatureFlags/src/SimpleModule.FeatureFlags/FeatureFlagSyncService.cs

@@ -1,4 +1,7 @@
+using System.Data.Common;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Storage;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
@@ -18,6 +21,19 @@ public async Task StartAsync(CancellationToken cancellationToken)
         using var scope = serviceProvider.CreateScope();
         var db = scope.ServiceProvider.GetRequiredService<FeatureFlagsDbContext>();
 
+        // Ensure module tables exist. EnsureCreated is a no-op when the database
+        // file already exists (created by the Host DbContext), so we call
+        // CreateTables directly and ignore the error if tables already exist.
+        try
+        {
+            var creator = db.Database.GetService<IRelationalDatabaseCreator>();
+            await creator.CreateTablesAsync(cancellationToken);
+        }
+        catch (DbException)
+        {
+            // Tables already exist — expected in normal operation
+        }
+
         var definitions = registry.GetAllDefinitions();
         var existingFlags = await db.FeatureFlags.ToListAsync(cancellationToken);
         var existingNames = existingFlags.ToDictionary(f => f.Name);

tests/e2e/pages/feature-flags/manage.page.ts

@@ -0,0 +1,49 @@
+import type { Page } from '@playwright/test';
+
+export class FeatureFlagsManagePage {
+  constructor(private page: Page) {}
+
+  async goto() {
+    await this.page.goto('/feature-flags');
+  }
+
+  get heading() {
+    return this.page.getByRole('heading', { name: /feature flags/i });
+  }
+
+  get flagTable() {
+    return this.page.getByRole('table');
+  }
+
+  get flagRows() {
+    return this.page.getByRole('row');
+  }
+
+  flagRow(name: string) {
+    return this.page.getByRole('row', { name: new RegExp(name, 'i') });
+  }
+
+  flagToggle(name: string) {
+    return this.flagRow(name).getByRole('switch');
+  }
+
+  overridesButton(name: string) {
+    return this.flagRow(name).getByRole('button', { name: /overrides/i });
+  }
+
+  get overrideDialog() {
+    return this.page.getByRole('dialog');
+  }
+
+  get addOverrideButton() {
+    return this.overrideDialog.getByRole('button', { name: /add override/i });
+  }
+
+  get overrideValueInput() {
+    return this.overrideDialog.getByLabel(/value/i);
+  }
+
+  get deprecatedSection() {
+    return this.page.getByText(/deprecated/i);
+  }
+}

tests/e2e/tests/flows/feature-flags-crud.spec.ts

@@ -0,0 +1,115 @@
+import { expect, test } from '../../fixtures/base';
+import { FeatureFlagsManagePage } from '../../pages/feature-flags/manage.page';
+
+test.describe('Feature Flags CRUD flows', () => {
+  test('toggle a feature flag and verify state persists', async ({ page, request }) => {
+    const manage = new FeatureFlagsManagePage(page);
+
+    // API: get all flags to find one to toggle
+    const flagsRes = await request.get('/api/feature-flags');
+    expect(flagsRes.ok()).toBeTruthy();
+    const flags = await flagsRes.json();
+    expect(flags.length).toBeGreaterThan(0);
+
+    const flag = flags[0];
+    const originalState = flag.isEnabled;
+
+    // API: toggle the flag
+    const toggleRes = await request.put(`/api/feature-flags/${encodeURIComponent(flag.name)}`, {
+      data: { isEnabled: !originalState },
+    });
+    expect(toggleRes.ok()).toBeTruthy();
+
+    // API: verify the state changed
+    const afterToggleRes = await request.get('/api/feature-flags');
+    const afterToggle = await afterToggleRes.json();
+    const toggled = afterToggle.find((f: { name: string }) => f.name === flag.name);
+    expect(toggled.isEnabled).toBe(!originalState);
+
+    // UI: verify the state on the manage page
+    await manage.goto();
+    await expect(manage.flagRow(flag.name)).toBeVisible();
+
+    // API: restore original state
+    await request.put(`/api/feature-flags/${encodeURIComponent(flag.name)}`, {
+      data: { isEnabled: originalState },
+    });
+  });
+
+  test('add and remove an override via API', async ({ request }) => {
+    // API: get a flag to work with
+    const flagsRes = await request.get('/api/feature-flags');
+    const flags = await flagsRes.json();
+    expect(flags.length).toBeGreaterThan(0);
+    const flag = flags[0];
+
+    // API: add a user override
+    const addRes = await request.post(
+      `/api/feature-flags/${encodeURIComponent(flag.name)}/overrides`,
+      {
+        data: {
+          overrideType: 0, // User
+          overrideValue: 'e2e-test-user',
+          isEnabled: true,
+        },
+      },
+    );
+    expect(addRes.ok()).toBeTruthy();
+    const override = await addRes.json();
+    expect(override.flagName).toBe(flag.name);
+    expect(override.overrideValue).toBe('e2e-test-user');
+
+    // API: verify override appears in list
+    const overridesRes = await request.get(
+      `/api/feature-flags/${encodeURIComponent(flag.name)}/overrides`,
+    );
+    expect(overridesRes.ok()).toBeTruthy();
+    const overrides = await overridesRes.json();
+    expect(
+      overrides.some((o: { overrideValue: string }) => o.overrideValue === 'e2e-test-user'),
+    ).toBeTruthy();
+
+    // API: delete the override
+    const deleteRes = await request.delete(`/api/feature-flags/overrides/${override.id}`);
+    expect(deleteRes.ok()).toBeTruthy();
+
+    // API: verify override is gone
+    const afterDeleteRes = await request.get(
+      `/api/feature-flags/${encodeURIComponent(flag.name)}/overrides`,
+    );
+    const afterDelete = await afterDeleteRes.json();
+    expect(
+      afterDelete.some((o: { overrideValue: string }) => o.overrideValue === 'e2e-test-user'),
+    ).toBeFalsy();
+  });
+
+  test('check endpoint returns flag state for current user', async ({ request }) => {
+    // API: get a flag
+    const flagsRes = await request.get('/api/feature-flags');
+    const flags = await flagsRes.json();
+    expect(flags.length).toBeGreaterThan(0);
+    const flag = flags[0];
+
+    // API: check endpoint
+    const checkRes = await request.get(`/api/feature-flags/check/${encodeURIComponent(flag.name)}`);
+    expect(checkRes.ok()).toBeTruthy();
+    const result = await checkRes.json();
+    expect(typeof result.isEnabled).toBe('boolean');
+  });
+
+  test('overrides dialog opens from manage page', async ({ page, request }) => {
+    const manage = new FeatureFlagsManagePage(page);
+
+    // API: get a flag name
+    const flagsRes = await request.get('/api/feature-flags');
+    const flags = await flagsRes.json();
+    expect(flags.length).toBeGreaterThan(0);
+    const flagName = flags[0].name;
+
+    // UI: navigate and open overrides dialog
+    await manage.goto();
+    await manage.overridesButton(flagName).click();
+    await expect(manage.overrideDialog).toBeVisible();
+    await expect(manage.addOverrideButton).toBeVisible();
+  });
+});

tests/e2e/tests/smoke/feature-flags.spec.ts

@@ -0,0 +1,16 @@
+import { expect, test } from '../../fixtures/base';
+import { FeatureFlagsManagePage } from '../../pages/feature-flags/manage.page';
+
+test.describe('Feature Flags pages', () => {
+  test('manage page loads', async ({ page }) => {
+    const manage = new FeatureFlagsManagePage(page);
+    await manage.goto();
+    await expect(manage.heading).toBeVisible();
+  });
+
+  test('manage page shows flag table', async ({ page }) => {
+    const manage = new FeatureFlagsManagePage(page);
+    await manage.goto();
+    await expect(manage.flagTable).toBeVisible();
+  });
+});