diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index 8edbd79..2cb7a0c 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -20,6 +20,7 @@ Fixes [SRVOCF-XXX](https://redhat.atlassian.net/browse/SRVOCF-XXX)
 ## Checklist
 
 - [ ] Updated `docs/ARCHITECTURE.md` (if there are relevant changes to our layered architecture)
+- [ ] Updated `docs/TESTING.md` (if there are relevant changes to our testing framework or setup)
 
 <!--
 ## Screenshots
diff --git a/docs/AGILE.md b/docs/AGILE.md
index 398db37..a0bf08b 100644
--- a/docs/AGILE.md
+++ b/docs/AGILE.md
@@ -56,30 +56,22 @@ The rest of the team reviews refined stories in Jira and leaves comments.
 
 ## Sync Ceremonies
 
-**Iteration Planning** (start of iteration, 20 min)
+**Weekly Sync + Technical Discussions** (every Tue + Thu)
 
-- Each engineer selects refined stories from the backlog for the upcoming 3 weeks.
-- Stories must be refined before entering an iteration; otherwise, they return to refinement.
-- Engineers volunteer to take unrefined stories for refinement during the upcoming iteration.
+- Status sync first, then technical discussion.
 
-**Weekly Sync** (Wednesdays, 30 min)
+**Backlog Cleanup / Grooming** (every two weeks, Tue or Thu)
 
-- A quick round covering progress, blockers, and any decisions needed.
-- The facilitator runs the Jira sanity check for each engineer.
+- Go through all New / Backlog stories and bugs.
+- Prioritize, assign for refinement, close stale items, create new tickets, discuss as needed.
 
-**Optional Refinement Slot** (weekly, 45 min)
+**Review + Planning** (every three weeks on Thu, iteration end)
 
-- Intended for open questions from async refinement requiring face-to-face discussion.
-- The meeting itself is optional. When there is nothing to discuss the team is not expected to attend.
-- The PM is invited when their input is needed.
-- The facilitator cancels it if there is nothing to discuss.
+- Review first, then planning.
 
-**Iteration Review + Retrospective** (end of iteration, 60-75 min)
+**Retrospective** (every three weeks on Tue, iteration start)
 
-- First half (30 min): each engineer briefly demonstrates what they delivered.
-- Second half (30 min): reflecting on what went well, what didn't, and one thing to change next iteration.
-
-**Rotation:** The first facilitator is picked at kick-off. After every 2 iterations, the role rotates to the next person.
+- On weeks where the retrospective intersects with the backlog grooming meeting, grooming moves to Thu.
 
 ## Facilitator Jira Checklist
 
@@ -97,8 +89,7 @@ The facilitator checks the following for each engineer during the weekly sync:
 
 During rotation:
 
-- Set up sync ceremony meetings (planning, weekly sync, review + retro)
-- Inform the team if the optional refinement slot happens, latest on the day of
+- Set up sync ceremony meetings
 - Facilitate sync ceremonies: keep time and lead the agenda
 - Run the Jira sanity check during the weekly sync
 
diff --git a/docs/TESTING.md b/docs/TESTING.md
index c9d1b9d..9b17086 100644
--- a/docs/TESTING.md
+++ b/docs/TESTING.md
@@ -15,51 +15,35 @@ Do NOT write all test cases first and then implement everything at once.
 
 **Bug fixes require a regression test.** Add a unit test that reproduces the bug, or an e2e test if the bug is not testable at the unit level.
 
-## Test Layers
+## Test Double Terminology
 
-| Layer | Tool | Scope |
-|-------|------|-------|
-| Unit / Component | Vitest + React Testing Library | Hooks, services, component rendering, form logic |
-| E2e / Feature validation | Playwright | Validate user flows in real browser |
-| API mocking | MSW (Mock Service Worker) | GitHub API + K8s API — mock everything first, real cluster later |
+Not every test double is a mock. Use the correct term:
 
-## Mock Strategy
+| Term | Purpose | Examples |
+|------|---------|----------|
+| **Stub** | Returns canned responses, no behaviour verification | Backend: `scm.ClientStub`, `cluster.ClientStub`. Frontend: `listFunctionsStub` (MSW handler returning configured responses), `useK8sWatchResourceStub` |
+| **Fake** | Working implementation with shortcuts (e.g., in-memory store) | Backend: `fake.NewSimpleClientset` (in-memory K8s client). Frontend: `authenticateGithubFake` (populates sessionStorage instead of real OAuth) |
+| **Mock** | Asserts expectations inside the double | Use sparingly. Prefer stubs with assertions in the test body. |
+| **Spy** | Records calls for later assertion | Not currently used. Prefer asserting on observable output. |
 
-MSW is the primary mocking strategy for anything that hits the network (GitHub API, K8s API, Go backend). K8s API mocking uses MSW WebSocket capability.
+## Frontend
 
-`vi.mock` is only for framework and library internals that have no external service:
+### Running Frontend Unit Tests
 
-- `react-i18next` (translation hook)
-- `@openshift-console/dynamic-plugin-sdk` (console shell runtime components like DocumentTitle, ListPageHeader, consoleFetchJSON)
-- `@patternfly/react-icons` (UI library)
-- `react-router-dom-v5-compat` (framework routing)
-- `libsodium-wrappers` (WASM crypto library)
-
-If it makes an HTTP or WebSocket call, mock it with MSW, not `vi.mock`.
-
-## File Conventions
-
-| Type | Location |
-|------|----------|
-| Component tests | `src/pages/<name>/components/*.test.ts\|tsx`, `src/common/components/*.test.ts\|tsx` |
-| Page tests | `src/pages/<name>/*.test.ts\|tsx` |
-| Service / Hook / Util tests | `src/common/**/*.test.ts\|tsx` |
-| E2e specs | `e2e/use-cases/<feature-name>/*.test.ts` |
-| MSW handlers | `src/common/testing/mswServer.ts` |
+```bash
+make unit-frontend
+```
 
-## What Gets Tested
+### Page and Component Tests
 
-| Artifact | Test type | Example |
-|----------|-----------|---------|
-| Service interfaces | Unit | `FunctionService.generateFunction()` returns expected files |
-| React hooks | Unit | `useFunctionService()` returns service instance |
-| Components | Component | `CreateForm` renders all fields, validates input |
-| Pages | Component + E2e | `FunctionsListPage` shows empty state, table |
-| User flows | E2e | Create form → submit → list shows new function |
+Page tests are the primary entry point. They render the real page with all real child components and hooks. No test doubles for components or hooks, only for external boundaries (SDK, backend API). Page tests cover full user interaction flows end to end within the page.
 
-## Component vs. Page Tests
+**Page tests** cover:
 
-Every component gets its own exhaustive test file. Every page gets its own test file that tests the page's orchestration and integration with its components.
+- Full user interaction flows (refresh, namespace switch, error recovery)
+- Page-level states: loading, error, empty
+- Data flowing from real hooks through real components to the screen
+- Cross-component effects (e.g., form submit calls service, then navigates)
 
 **Component tests** cover:
 
@@ -67,16 +51,34 @@ Every component gets its own exhaustive test file. Every page gets its own test
 - User interactions that trigger callbacks (clicks, input, form validation)
 - Internal state (expand/collapse, selection)
 
-**Page tests** cover:
+Overlap between page tests and component tests is expected and acceptable. They test at different levels: page tests verify the page's orchestration logic works correctly, component tests verify the component works in isolation.
 
-- Component is present on the page and wired correctly
-- Data flows from hooks/services to components (correct props)
-- User actions that trigger cross-component effects or service calls (e.g., form submit calls service, then navigates)
-- Page-level states: loading, error, empty
+### Frontend Testing Framework
 
-Overlap between component tests and page tests is expected and acceptable. They test at different levels: component tests verify the component works in isolation, page tests verify the page's orchestration logic works correctly.
+Shared test infrastructure lives in `src/common/testing/`:
 
-## Testing Best Practices
+| File | Purpose |
+| ------ | --------- |
+| `sdkTestDoubles.tsx` | Stubs for OCP SDK hooks: `useK8sWatchResourceStub`, `useActiveNamespaceStub`, fixture builders (`ksvcFixture`, `deploymentFixture`) |
+| `functionsClientStub.ts` | MSW handler that intercepts `listFunctions` requests with configurable responses, errors, and delays |
+| `mswServer.ts` | MSW server with default backend API handlers (auth user, function list) |
+| `authFake.ts` | Session storage helpers to simulate GitHub authentication (`authenticateGithubFake`, `logoutGithubFake`) |
+| `constants.ts` | Shared test constants (`BACKEND_API` base URL) |
+
+### Frontend Test Double Strategy
+
+Tests replace external dependencies at two boundaries using test doubles:
+
+**Backend API (MSW).** `functionsClient.ts` calls the Go backend over HTTP. MSW intercepts these requests at the network level, so tests exercise the real client code (URL construction, query params, error handling) without replacing it. Test doubles are set up per test via helpers in `src/common/testing/functionsClientStub.ts`.
+
+**OCP SDK (test doubles via `vi.mock`).** The OCP dynamic plugin SDK provides hooks like `useK8sWatchResource` and `useActiveNamespace` that only work inside the console shell. Tests replace them with self-written stubs from `src/common/testing/sdkTestDoubles.tsx`, injected through `vi.mock('@openshift-console/dynamic-plugin-sdk')`. The stubs accept raw K8s resource fixtures (Knative Services, Deployments) and let the real hooks (e.g., `useCluster`) derive status, replicas, and URL. This catches shape mismatches at test time instead of hiding them behind pre-computed return values.
+
+`vi.mock` is also used for framework internals that have no external service and cannot run outside their host environment:
+
+- `react-i18next` (translation hook)
+- `@patternfly/react-icons` (UI library)
+
+### Frontend Testing Practices & Conventions
 
 1. **User-Centric Testing** — Test what users see and interact with.
    Do NOT test: internal component state, private methods, props passed to children, CSS class names, component structure.
@@ -88,38 +90,90 @@ Overlap between component tests and page tests is expected and acceptable. They
 4. **TypeScript Safety** — Use proper types for props, state, and mock data.
 
 5. **Arrange-Act-Assert (AAA)** — Structure every test:
-   - **Arrange:** Render component with mocks
-   - **Act:** Perform user actions
+   - **Arrange:** Set up test doubles
+   - **Act:** Render the component or perform user actions
    - **Assert:** Verify expected state
 
+   ```typescript
+   it('shows NotDeployed status for repos without cluster deployment', async () => {
+     // Arrange
+     listFunctionsStub({ responses: [repoListItem('orphan-func', 'orphan-func', 'demo', 'node')] });
+
+     // Act
+     render(
+       <MemoryRouter>
+         <FunctionsListPage />
+       </MemoryRouter>,
+     );
+
+     // Assert
+     expect(await screen.findByText('Info: NotDeployed')).toBeInTheDocument();
+   });
+   ```
+
 6. **Scoping** — Place beforeEach, afterEach, and afterAll inside describe blocks.
 
-## Mocking Patterns
+7. **Hook tests use `renderHook`** — Test hooks directly with `renderHook` from `@testing-library/react`. Assert on `result.current` instead of rendering a consumer component and querying the DOM.
 
-MSW is the primary approach. `vi.mock` is rare (see Mock Strategy above).
+   ```typescript
+   const { result } = renderHook(() => useCluster([funcName], namespace));
 
-Use ESM `import` at top of file. Never use `require('react')` or `React.createElement()` in mocks.
-Keep mocks simple.
+   expect(result.current.loaded).toBe(true);
+   expect(result.current.functions.size).toBe(0);
+   ```
 
-**Correct patterns (for the rare `vi.mock` cases):**
+8. **`server.boundary()` for infinite delays** — When a test uses `delay('infinite')` to verify loading states, wrap the test in `server.boundary()`. This scopes MSW handlers to the test and prevents in-flight requests from leaking across test boundaries (`resetHandlers()` alone does not abort in-flight requests).
 
-```typescript
-// Return null
-vi.mock('../MyComponent', () => () => null);
+   ```typescript
+   it(
+     'shows loading state while fetching',
+     server.boundary(async () => {
+       server.use(
+         http.get(`${BACKEND_API}/api/v1/func/.../files`, async () => {
+           await delay('infinite');
+           return HttpResponse.json([]);
+         }),
+       );
+
+       render(<MyPage />);
 
-// Return string
-vi.mock('../LoadingSpinner', () => () => 'Loading...');
+       expect(screen.getByText('Loading...')).toBeInTheDocument();
+     }),
+   );
+   ```
 
-// Return children directly
-vi.mock('../Wrapper', () => ({ children }) => children);
+### `vi.mock`
 
-// Track calls with vi.fn
-vi.mock('../ButtonBar', () => vi.fn(({ children }) => children));
+Avoid `vi.mock` mostly. It is only for external boundaries that cannot be intercepted at the network level (see "Test Doubles" above). Do not use `vi.mock` to replace components or hooks. If a component or hook is hard to test without replacing it, that is a design issue.
 
-// Mock framework hooks
+Use ESM `import` at top of file. Keep test doubles simple.
+
+**Allowed patterns:**
+
+```typescript
+// Framework internals
 vi.mock('react-i18next', () => ({
   useTranslation: () => ({ t: (key: string) => key }),
 }));
+
+// OCP SDK boundary — load test doubles via vi.hoisted so they are
+// available inside the vi.mock factory (which is hoisted above imports)
+const sdkTestDoubles = await vi.hoisted(async () => import('../../common/testing/sdkTestDoubles'));
+
+vi.mock('@openshift-console/dynamic-plugin-sdk', async () => ({
+  useK8sWatchResource: sdkTestDoubles.useK8sWatchResourceStub,
+  useActiveNamespace: sdkTestDoubles.useActiveNamespaceStub,
+  // ... remaining SDK exports as simple stubs
+}));
+```
+
+**Clean up:**
+
+```typescript
+// always put inside a describe block
+afterEach(() => {
+  vi.restoreAllMocks();
+});
 ```
 
 **Forbidden patterns:**
@@ -135,23 +189,74 @@ vi.mock('../Component', () => {
 vi.mock('../Component', () => () => <div>Mock</div>);
 ```
 
-**Clean up mocks:**
+---
 
-```typescript
-afterEach(() => {
-  vi.restoreAllMocks();
-});
-```
+## Backend
 
-### Running unit tests
+Ginkgo v2 + Gomega for specs. No other third-party test libraries.
+
+### Running Backend Unit Tests
 
 ```bash
-make unit-frontend
+make unit-backend
+```
+
+### Backend Testing Framework
+
+Test double stubs live next to their interfaces:
+
+| File | Purpose |
+|------|---------|
+| `scm/client.go` (`ClientStub`) | Stub for `scm.Client` with function fields for each method (GetUser, ListRepos, PushFiles, etc.) |
+| `cluster/client.go` (`ClientStub`) | Stub for `cluster.Client` with function fields for RBAC and token operations |
+| `functions/client.go` (`ClientStub`) | Stub for `functions.Client` with a function field for List |
+| `handler/common_test.go` | Injection helpers: `withSCMStub`, `withClusterStub`, `withFunctionsClient` swap the production factory for a test stub via `DeferCleanup` |
+
+### Backend Test Double Strategy
+
+Two strategies depending on the package under test:
+
+**Interface-level stubs** (handler tests) - `scm.ClientStub`, `cluster.ClientStub`, and `functions.ClientStub` implement their respective interfaces with function fields. Each test sets only the fields it exercises; unset fields return happy-path defaults. `withSCMStub` swaps `config.SCMRegistry`, `withClusterStub` swaps `newClusterClient`, and `withFunctionsClient` swaps `newFunctionsClient` for the duration of the test. No `httptest.NewServer`, no real HTTP client stack - handler tests verify request parsing, error mapping, and response codes only.
+
+**`fake.NewSimpleClientset`** (cluster package tests) - `k8s.io/client-go/kubernetes/fake` implements `kubernetes.Interface` without any HTTP. Use reactors to simulate errors and pre-populate objects to simulate existing state. This is the client-go idiomatic approach.
+
+Tests live in the same package as the code (`package handler`, `package cluster`) for white-box access. Each package has a `suite_test.go` that registers the Ginkgo runner.
+
+### Spec Pattern
+
+Handler tests call `withSCMStub(&scm.ClientStub{...})`, `withClusterStub(&cluster.ClientStub{...})`, and `withFunctionsClient(&functions.ClientStub{...})` to inject interface-level stubs. Cluster tests inject `fake.NewSimpleClientset()` directly. Each test owns its own setup - no shared state.
+
+Use `DeferCleanup` for teardown, not `defer`.
+
+### Tests are Use Cases
+
+Each `It(...)` describes a behaviour from the caller's perspective. The description says **what the system does**, not which function was called.
+
+```
+// Bad — method-focused
+It("TestCreateBlob_HappyPath")
+
+// Good — use case
+It("commits all files to the branch")
 ```
 
-## E2e Conventions
+Use `DescribeTable` / `Entry` for validation and error variants to keep them concise.
 
-E2e tests run against a real OpenShift cluster. GitHub API calls are intercepted with `page.route()` mocks, while K8s API calls go to the real cluster. Each test file covers a single use case, exercising a flow from start to finish with `test.step` for structure.
+### Backend Testing Practices & Conventions
+
+- `It(...)` descriptions are use cases, not method names
+- Every use case needs at minimum: the success path + the main failure path
+- Test behaviour, not call counts
+- Keep fake servers inline — no shared mock fixtures
+- **Assert at the test level, not inside stubs.** Stubs return canned data. They must not contain `Expect` calls or spy booleans. Capture request data into variables and assert on them in the `It(...)` body.
+- **Success tests: assert the return AND the final request data.** For multi-step operations (e.g., getRef -> getCommit -> createBlob -> createTree -> createCommit -> updateRef), don't assert that each step was called. The stub already ensures that: if a step is skipped, later steps won't receive the data they need and the call will fail. Assert that the return is not an error, then verify what the last request received, which is the accumulation of all prior operations. This avoids coupling tests to the full implementation while still capturing what matters.
+- **Error tests: one test per endpoint.** Each test fails a single endpoint and verifies the error propagates correctly with the right wrapping message.
+
+---
+
+## E2E Tests
+
+E2E tests run against a real OpenShift cluster. GitHub API calls are intercepted with `page.route()` mocks, while K8s API calls go to the real cluster. Each test file covers a single use case, exercising a flow from start to finish with `test.step` for structure.
 
 ### Prerequisites
 
@@ -167,7 +272,7 @@ E2e tests run against a real OpenShift cluster. GitHub API calls are intercepted
 | `BRIDGE_BASE_ADDRESS` | Console URL (default: `http://localhost:9000`) | No |
 | `BRIDGE_KUBEADMIN_PASSWORD` | Cluster login password | Only when auth is enabled |
 
-### Running
+### Running E2E Tests
 
 ```bash
 make test-e2e                                                   # all tests, headless
@@ -180,50 +285,80 @@ yarn test:e2e:report                                            # open HTML repo
 
 ### File Structure
 
-```
+```txt
 e2e/
   auth.setup.ts                    # Playwright login setup (saves storageState)
+  global-setup.ts                  # Global setup (operator install, namespace)
   fixtures/
-    authenticated-page.ts          # Custom test fixture: injects GitHub mock + PAT
+    authenticated-page.ts          # Custom test fixture: injects PAT into sessionStorage
   helpers/
     cluster.ts                     # K8s API helpers (namespace, operator, deploy)
+    constants.ts                   # Shared constants (PRESEEDED_FUNC_NAME, E2E_USER, etc.)
+    fakegithub.ts                  # Fake GitHub server helpers (seed, reset, delete repos)
     navigation.ts                  # Page navigation helpers
     ui.ts                          # Dialog dismissal, loading spinners
-  mocks/
-    github.ts                      # Stateful GitHub API mock (page.route)
   use-cases/
     creation/                      # Create function tests
     delete/                        # Delete/undeploy function tests
+    edit/                          # Edit function tests
+    list/                          # List and namespace scoping tests
 ```
 
-### Fixtures and Mocks
+### E2E Test File Template
 
-Tests import `test` and `expect` from `e2e/fixtures/authenticated-page.ts`, not from `@playwright/test` directly. The fixture automatically installs the GitHub API mock and injects a placeholder PAT into sessionStorage before each test.
+```typescript
+import { test, expect } from '../../fixtures/authenticated-page';
+import { navigateToFunctionsList } from '../../helpers/navigation';
+import { PRESEEDED_FUNC_NAME as FUNC_NAME } from '../../helpers/constants';
 
-The GitHub mock (`e2e/mocks/github.ts`) is stateful. It maintains seed repos and tracks dynamically created repos through the full `createRepoWithSecret` flow. It exports one constant used by tests:
+test.describe('My feature', () => {
+  test('user does something', async ({ page }) => {
+    await test.step('navigate to functions list', async () => {
+      await navigateToFunctionsList(page);
+    });
+
+    await test.step('verify expected state', async () => {
+      const grid = page.getByRole('grid', { name: 'Functions' });
+      await expect(grid).toBeVisible({ timeout: 30_000 });
+    });
+  });
+});
+```
+
+### E2E Test Doubles
+
+Tests import `test` and `expect` from `e2e/fixtures/authenticated-page.ts`, not from `@playwright/test` directly. The fixture injects a placeholder PAT and user into sessionStorage before each test.
+
+The fake GitHub server (`e2e/helpers/fakegithub.ts`) provides helpers for seeding, resetting, and deleting repos. Shared constants live in `e2e/helpers/constants.ts`:
 
 - `PRESEEDED_FUNC_NAME` ('preseeded-test-func'): a seed repo, used by list, edit, and delete tests
+- `E2E_USER` ('e2e-user'): the test user identity
 
 ### Helpers
 
+**Auth** - Login is handled by `e2e/auth.setup.ts`, which saves session state via Playwright's `storageState`. The authenticated-page fixture then injects the PAT and user into sessionStorage on top of that session.
+
 **Navigation** (`e2e/helpers/navigation.ts`)
 
 | Helper | Purpose |
-|--------|---------|
+| -------- | --------- |
 | `navigateToFunctionsList(page)` | Go to `/faas`, dismiss dialogs, wait for load |
 | `navigateToFunctionsTable(page)` | Navigate to list and wait for the functions grid |
 | `navigateToCreatePage(page)` | Go to `/faas/create` |
 | `navigateToEditPage(page, repoName?)` | Go to edit page directly or via list table |
+| `selectNamespace(page, namespace)` | Select a specific namespace in the project selector |
+| `selectAllNamespaces(page)` | Select "All Namespaces" in the project selector |
 
 **Cluster** (`e2e/helpers/cluster.ts`)
 
 | Helper | Purpose |
-|--------|---------|
+| -------- | --------- |
 | `k8sHeaders(page)` | Get CSRF token headers for K8s API calls |
 | `ensureNamespace(page, name)` | Create namespace if it doesn't exist (waits for terminating namespaces) |
 | `ensureSecret(page, ns, name, data)` | Create a Secret if it doesn't exist (base64-encodes data values) |
 | `ensureConfigMap(page, ns, name, data)` | Create a ConfigMap if it doesn't exist |
 | `simulateGitHubActionsDeploy(page, name, ns)` | Create a ksvc and patch the deployment label to simulate `func deploy` |
+| `deleteFunction(page, name, namespace)` | Delete a function's ksvc and deployment from the cluster |
 | `ksvcApiPath(ns)` / `deploymentApiPath(ns)` | Build K8s API paths for Knative services and deployments |
 
 **UI** (`e2e/helpers/ui.ts`)
@@ -246,7 +381,7 @@ page.locator('#name')  // form inputs with HTML id
 **PatternFly 6 ARIA gotchas:**
 
 | PF6 Component | Renders as | Use |
-|---------------|-----------|-----|
+| --------------- | ----------- | ----- |
 | Table (sortable/interactive) | `role="grid"` | `getByRole('grid')`, not `getByRole('table')` |
 | Button with `component="a"` | `<a>` with `role="link"` | `getByRole('link')`, not `getByRole('button')` |
 | Modal backdrop (stacked) | Intercepts pointer events | `evaluate((el: HTMLElement) => el.click())` to bypass |
@@ -273,19 +408,13 @@ await expect
 
 All cluster helpers in `e2e/helpers/cluster.ts` follow this pattern.
 
-### Playwright Route LIFO Ordering
-
-Playwright evaluates `page.route()` handlers in LIFO (last-in, first-out) order. Routes registered last are checked first. When a test needs to override the GitHub mock catch-all (e.g., for the duplicate-name error test), register the override after the fixture has set up the catch-all.
-
-### Auth
-
-Login is handled by `e2e/auth.setup.ts`, which saves session state via Playwright's `storageState`. The authenticated-page fixture then injects the GitHub mock and PAT on top of that session.
+---
 
-## CI E2e (Prow)
+## CI E2E (Prow)
 
-E2e tests also run in CI via Prow/ci-operator against an ephemeral OCP cluster on AWS.
+E2E tests also run in CI via Prow/ci-operator against an ephemeral OCP cluster on AWS.
 
-### How it works
+### How it Works
 
 1. ci-operator provisions an ephemeral cluster from the `openshift-org-aws` pool
 2. The `install-operators` pre-step installs the Serverless operator from `redhat-operators`
@@ -302,100 +431,15 @@ E2e tests also run in CI via Prow/ci-operator against an ephemeral OCP cluster o
 
 The ci-operator job config lives in the `openshift/release` repo at `ci-operator/config/openshift/faas-console-plugin/`.
 
-### Prow jobs
+### Prow Jobs
 
 | Job | Type | What it runs |
-|-----|------|-------------|
+| ----- | ------ | ------------- |
 | `images` | Image build | Builds the plugin container image from `Dockerfile` (automatic ci-operator job) |
 | `lint` | Container test (no cluster) | `make lint` |
 | `unit` | Container test (no cluster) | `make unit` |
 | `e2e-aws` | Cluster test | `make e2e` against an ephemeral OCP cluster (with Serverless + Pipelines operators pre-installed) |
 
-### Local vs CI differences
+### Local vs CI Differences
 
 In local dev, `simulateGitHubActionsDeploy()` calls `ensureServerlessOperator()` to install the operator if it is missing.
-
-### Test file template
-
-```typescript
-import { test, expect } from '../../fixtures/authenticated-page';
-import { navigateToFunctionsList } from '../../helpers/navigation';
-import { PRESEEDED_FUNC_NAME as FUNC_NAME } from '../../mocks/github';
-
-test.describe('My feature', () => {
-  test('user does something', async ({ page }) => {
-    await test.step('navigate to functions list', async () => {
-      await navigateToFunctionsList(page);
-    });
-
-    await test.step('verify expected state', async () => {
-      const grid = page.getByRole('grid', { name: 'Functions' });
-      await expect(grid).toBeVisible({ timeout: 30_000 });
-    });
-  });
-});
-```
-
----
-
-## Backend (Go)
-
-Ginkgo v2 + Gomega for specs. No other third-party test libraries.
-
-### Test Double Terminology
-
-Not every test double is a mock. Use the correct term for what the double does:
-
-| Term | Purpose | Naming convention | Example |
-|------|---------|-------------------|---------|
-| **Stub** | Returns canned responses, no behaviour verification | `scmStub`, `clusterStub` | `&scmStub{getUser: func(...) { return &scm.User{...}, nil }}` |
-| **Mock** | Asserts expectations inside the handler | `mock` | Test double with inline `Expect(...)` |
-| **Spy** | Records calls for later assertion | `callsSpy` | `map[string]int{}` tracking which operations ran |
-| **Helper** | Records a call into a spy | `recordCall` | `func(key string) { callsSpy[key]++ }` |
-
-### Test Double Strategy
-
-Two strategies depending on the package under test:
-
-**Interface-level stubs** (handler tests) - `scmStub` and `clusterStub` implement `scm.Client` and `cluster.Client` with function fields. Each test sets only the fields it exercises; unset fields return happy-path defaults. `withSCMStub` swaps `config.SCMRegistry` and `withClusterStub` swaps `newClusterClient` for the duration of the test. No `httptest.NewServer`, no real HTTP client stack - handler tests verify request parsing, error mapping, and response codes only.
-
-**`fake.NewSimpleClientset`** (cluster package tests) - `k8s.io/client-go/kubernetes/fake` implements `kubernetes.Interface` without any HTTP. Use reactors to simulate errors and pre-populate objects to simulate existing state. This is the client-go idiomatic approach.
-
-Tests live in the same package as the code (`package handler`, `package cluster`) for white-box access. Each package has a `suite_test.go` that registers the Ginkgo runner.
-
-### Spec pattern
-
-Handler tests call `withSCMStub(&scmStub{...})` and `withClusterStub(&clusterStub{...})` to inject interface-level stubs. Cluster tests inject `fake.NewSimpleClientset()` directly. Each test owns its own setup - no shared state.
-
-Use `DeferCleanup` for teardown, not `defer`.
-
-
-### Tests are use cases
-
-Each `It(...)` describes a behaviour from the caller's perspective. The description says **what the system does**, not which function was called.
-
-```
-// Bad — method-focused
-It("TestCreateBlob_HappyPath")
-
-// Good — use case
-It("commits all files to the branch")
-```
-
-Use `DescribeTable` / `Entry` for validation and error variants to keep them concise.
-
-### Rules
-
-- `It(...)` descriptions are use cases, not method names
-- Every use case needs at minimum: the success path + the main failure path
-- Test behaviour, not call counts
-- Keep fake servers inline — no shared mock fixtures
-- **Assert at the test level, not inside stubs.** Stubs return canned data. They must not contain `Expect` calls or spy booleans. Capture request data into variables and assert on them in the `It(...)` body.
-- **Success tests: assert the return AND the final request data.** For multi-step operations (e.g., getRef -> getCommit -> createBlob -> createTree -> createCommit -> updateRef), don't assert that each step was called. The stub already ensures that: if a step is skipped, later steps won't receive the data they need and the call will fail. Assert that the return is not an error, then verify what the last request received, which is the accumulation of all prior operations. This avoids coupling tests to the full implementation while still capturing what matters.
-- **Error tests: one test per endpoint.** Each test fails a single endpoint and verifies the error propagates correctly with the right wrapping message.
-
-### Running
-
-```bash
-make unit-backend
-```