E2E Test Data Setup Runbook

Practical guide for creating test data to exercise Flows 4-7 (bid creation, response drafting, export, and template completion) without requiring real tender documents or AI API calls.

Key insight: Flows 6 (Export) and 7 (Template Completion) are fully deterministic. By inserting responses directly via SQL, you can test export and template completion with zero AI API calls.

1. Prerequisites

Requirement	How to verify
Dev server running	`bun dev` — visit `http://localhost:3000`
Python worker (for template ops only)	`PYTHONUNBUFFERED=1 python3 scripts/bid_worker.py`
Supabase connection	`.env.local` has `NEXT_PUBLIC_SUPABASE_URL` and `NEXT_PUBLIC_SUPABASE_ANON_KEY`
Authenticated session	Logged in at `http://localhost:3000/login` as admin or editor
Browser cookies	All API calls below require the Supabase auth cookie from the browser

For API calls from the command line, you need an active session token. The easiest approach is to use the browser’s fetch() from the DevTools console, or use a tool like curl with the Supabase auth headers.

Environment variables

1
NEXT_PUBLIC_SUPABASE_URL=https://rovrymhhffssilaftdwd.supabase.co
2
NEXT_PUBLIC_SUPABASE_ANON_KEY=<your-anon-key>
3
ANTHROPIC_API_KEY=<only-needed-for-Flow-5-AI-drafting>

2. Test Data Strategy

Naming convention

All E2E test data uses a distinctive naming convention so it can be easily identified and cleaned up:

Entity	Convention	Example
Bid name	`[E2E Test]` prefix	`[E2E Test] IT Support Services`
Buyer	`E2E Test Corp`	`E2E Test Corp`
Template name	`[E2E Test]` prefix	`[E2E Test] Response Template`

Differentiation from client data

Test data lives alongside real data in the same Supabase project
The [E2E Test] prefix makes it visually distinct in the bid list
Cleanup queries (see Section 8) filter on this prefix

3. Creating a Test Bid

Step 3a: Create the bid

1
// Browser DevTools console (or equivalent HTTP client)
2
const res = await fetch('/api/bids', {
3
  method: 'POST',
4
  headers: { 'Content-Type': 'application/json' },
5
  body: JSON.stringify({
6
    name: '[E2E Test] IT Support Services',
7
    buyer: 'E2E Test Corp',
8
    deadline: new Date(Date.now() + 14 * 86400000).toISOString().split('T')[0],
9
    description: 'E2E test bid for automated testing',
10
  }),
11
});
12
const bid = await res.json();
13
const BID_ID = bid.id;
14
console.log('Bid ID:', BID_ID);

Expected response: HTTP 201 with the bid object. Status will be draft.

Step 3b: Add questions (batch)

1
const questionsRes = await fetch(`/api/bids/${BID_ID}/questions`, {
2
  method: 'POST',
3
  headers: { 'Content-Type': 'application/json' },
4
  body: JSON.stringify({
5
    questions: [
6
      {
7
        section_name: 'Technical',
8
        section_sequence: 1,
9
        question_sequence: 1,
10
        question_text:
11
          'Describe your approach to providing IT support services including response times and escalation procedures.',
12
        word_limit: 500,
13
        category: 'technical',
14
      },
15
      {
16
        section_name: 'Technical',
17
        section_sequence: 1,
18
        question_sequence: 2,
19
        question_text:
20
          'What experience does your organisation have delivering similar IT support contracts in the public sector?',
21
        word_limit: 400,
22
        category: 'experience',
23
      },
24
      {
25
        section_name: 'Social Value',
26
        section_sequence: 2,
27
        question_sequence: 1,
28
        question_text:
29
          'Describe how you will deliver social value through this contract, including apprenticeships and local employment.',
30
        word_limit: 300,
31
        category: 'social_value',
32
      },
33
      {
34
        section_name: 'Commercial',
35
        section_sequence: 3,
36
        question_sequence: 1,
37
        question_text:
38
          'Provide a breakdown of your pricing model including any assumptions or exclusions.',
39
        word_limit: 600,
40
        category: 'commercial',
41
      },
42
    ],
43
  }),
44
});
45
const { questions, count } = await questionsRes.json();
46
console.log(`Created ${count} questions`);
47
// Save question IDs for later use
48
const QUESTION_IDS = questions.map((q) => q.id);
49
console.log('Question IDs:', QUESTION_IDS);

Expected response: HTTP 201 with { questions: [...], count: 4 }.

Step 3c: Advance bid state to `drafting`

The bid state machine requires sequential transitions. Advance through the required states:

1
// draft -> questions_extracted
2
await fetch(`/api/bids/${BID_ID}`, {
3
  method: 'PATCH',
4
  headers: { 'Content-Type': 'application/json' },
5
  body: JSON.stringify({ status: 'questions_extracted' }),
6
});
7

8
// questions_extracted -> matching
9
await fetch(`/api/bids/${BID_ID}`, {
10
  method: 'PATCH',
11
  headers: { 'Content-Type': 'application/json' },
12
  body: JSON.stringify({ status: 'matching' }),
13
});
14

15
// matching -> drafting
16
await fetch(`/api/bids/${BID_ID}`, {
17
  method: 'PATCH',
18
  headers: { 'Content-Type': 'application/json' },
19
  body: JSON.stringify({ status: 'drafting' }),
20
});
21

22
console.log('Bid advanced to drafting');

Each PATCH returns the updated bid object. The state machine enforces valid transitions:

1
draft -> questions_extracted -> matching -> drafting -> in_review -> ready_for_export -> submitted

4. Creating Responses WITHOUT AI

This is the key technique for testing Flows 6 and 7 without any AI API calls. Instead of calling the drafting endpoint (which invokes Claude), insert responses directly via SQL.

Option A: Direct SQL (via Supabase MCP or Dashboard)

1
-- Insert test responses for each question
2
-- Replace the UUIDs with your actual BID_ID and QUESTION_IDS
3

4
INSERT INTO bid_responses (question_id, response_text, review_status, drafted_by, metadata)
5
VALUES
6
  (
7
    '<QUESTION_ID_1>',
8
    '<p>Our IT support approach provides a comprehensive three-tier response structure. <strong>Priority 1 (Critical)</strong> issues affecting business operations receive a 15-minute response time with continuous work until resolution. <strong>Priority 2 (High)</strong> issues receive a 1-hour response with resolution within 4 hours. <strong>Priority 3 (Standard)</strong> requests are acknowledged within 4 hours and resolved within 2 business days.</p><p>Our escalation procedure follows a clear chain: Service Desk Analyst to Technical Lead (30 minutes), Technical Lead to Service Delivery Manager (1 hour), and Service Delivery Manager to Account Director (2 hours).</p>',
9
    'approved',
10
    '<YOUR_USER_UUID>',
11
    '{"quality_data": {"word_count": 95, "overall_score": 85, "word_limit_compliance": true}}'::jsonb
12
  ),
13
  (
14
    '<QUESTION_ID_2>',
15
    '<p>We have delivered IT support contracts across the public sector for over 10 years. Key examples include a 5-year contract with NHS Digital providing service desk and desktop support to 3,000 users, and a 3-year contract with the Department for Education covering infrastructure monitoring and incident management.</p><p>These contracts have consistently achieved 99.5% SLA compliance and maintained customer satisfaction scores above 4.5/5.</p>',
16
    'approved',
17
    '<YOUR_USER_UUID>',
18
    '{"quality_data": {"word_count": 75, "overall_score": 80, "word_limit_compliance": true}}'::jsonb
19
  ),
20
  (
21
    '<QUESTION_ID_3>',
22
    '<p>Social value is integral to our delivery model. We commit to creating a minimum of 2 apprenticeship positions per year of contract operation, recruiting from the local area within a 30-mile radius of the delivery site.</p><p>We will partner with local colleges to provide work experience placements and contribute 40 hours of pro-bono IT support to local charities annually.</p>',
23
    'approved',
24
    '<YOUR_USER_UUID>',
25
    '{"quality_data": {"word_count": 65, "overall_score": 78, "word_limit_compliance": true}}'::jsonb
26
  ),
27
  (
28
    '<QUESTION_ID_4>',
29
    '<p>Our pricing model is based on a fixed monthly service charge covering all BAU support activities. The monthly charge includes: Service Desk (8am-6pm weekdays), on-site engineering (2 FTE), infrastructure monitoring (24/7), and quarterly service reviews.</p><p><strong>Assumptions:</strong> Maximum 500 supported users, standard desktop/laptop estate, existing network infrastructure in place. <strong>Exclusions:</strong> Hardware procurement, project-based work, and out-of-hours support (available as an add-on).</p>',
30
    'approved',
31
    '<YOUR_USER_UUID>',
32
    '{"quality_data": {"word_count": 85, "overall_score": 82, "word_limit_compliance": true}}'::jsonb
33
  );

Option B: Via API (if you want responses visible in the response editor)

If you prefer to create responses via the API, you can use the response update endpoint after creating empty records. However, the drafting endpoints require ANTHROPIC_API_KEY. The SQL approach above is simpler for testing.

Step 4b: Approve responses via API

If you inserted responses with review_status: 'approved' in the SQL above, this step is already done. If you used a different status, approve each response:

1
// Fetch responses to get their IDs
2
const respRes = await fetch(`/api/bids/${BID_ID}/questions`);
3
const { questions: qs } = await respRes.json();
4

5
for (const q of qs) {
6
  if (q.response?.id) {
7
    await fetch(`/api/bids/${BID_ID}/responses/${q.response.id}`, {
8
      method: 'PATCH',
9
      headers: { 'Content-Type': 'application/json' },
10
      body: JSON.stringify({ review_status: 'approved' }),
11
    });
12
  }
13
}
14
console.log('All responses approved');

Step 4c: Advance to `ready_for_export`

1
// drafting -> in_review
2
await fetch(`/api/bids/${BID_ID}`, {
3
  method: 'PATCH',
4
  headers: { 'Content-Type': 'application/json' },
5
  body: JSON.stringify({ status: 'in_review' }),
6
});
7

8
// in_review -> ready_for_export
9
await fetch(`/api/bids/${BID_ID}`, {
10
  method: 'PATCH',
11
  headers: { 'Content-Type': 'application/json' },
12
  body: JSON.stringify({ status: 'ready_for_export' }),
13
});
14

15
console.log('Bid ready for export');

5. Running Flow 6: Export

With the bid in ready_for_export state and approved responses in place, export is fully deterministic — no AI calls needed.

Export as DOCX

1
const docxRes = await fetch(`/api/bids/${BID_ID}/export/docx`, {
2
  method: 'POST',
3
  headers: { 'Content-Type': 'application/json' },
4
  body: JSON.stringify({}),
5
});
6

7
// Download the file
8
const blob = await docxRes.blob();
9
const url = URL.createObjectURL(blob);
10
const a = document.createElement('a');
11
a.href = url;
12
a.download = 'test-export.docx';
13
a.click();

Verification checklist:

File downloads without errors
Document contains bid name as title
All 4 questions are present with section headings
All 4 approved responses are rendered
Word count metadata is present
Formatting (bold, paragraphs) is preserved from HTML

Export as XLSX

1
const xlsxRes = await fetch(`/api/bids/${BID_ID}/export/xlsx`, {
2
  method: 'POST',
3
  headers: { 'Content-Type': 'application/json' },
4
  body: JSON.stringify({}),
5
});
6

7
const blob = await xlsxRes.blob();
8
const url = URL.createObjectURL(blob);
9
const a = document.createElement('a');
10
a.href = url;
11
a.download = 'test-export.xlsx';
12
a.click();

Verification checklist:

File downloads without errors
Spreadsheet has headers: Section, Question, Word Limit, Response, Status
All 4 questions and responses are present
Data is correctly aligned in columns

Export options

Both export endpoints accept optional configuration:

1
// DOCX with all options
2
await fetch(`/api/bids/${BID_ID}/export/docx`, {
3
  method: 'POST',
4
  headers: { 'Content-Type': 'application/json' },
5
  body: JSON.stringify({
6
    include_cover: true,
7
    include_toc: true,
8
    include_citations: false,
9
    include_unanswered: false,
10
    company_name: 'E2E Test Corp',
11
  }),
12
});

6. Running Flow 7: Template Completion

Template completion requires the Python worker for analysis and filling steps. Ensure it is running before starting.

Step 6a: Upload a template

Use the test fixture at __tests__/fixtures/simple-template.docx:

1
const formData = new FormData();
2
// In a browser, use a file input or fetch the fixture
3
const fileInput = document.querySelector('input[type="file"]');
4
formData.append('file', fileInput.files[0]);
5
formData.append('name', '[E2E Test] Response Template');
6

7
const uploadRes = await fetch(`/api/bids/${BID_ID}/templates`, {
8
  method: 'POST',
9
  body: formData, // No Content-Type header -- browser sets multipart boundary
10
});
11
const template = await uploadRes.json();
12
const TEMPLATE_ID = template.id;
13
console.log('Template ID:', TEMPLATE_ID);

Expected response: HTTP 201 with template object, status: 'uploaded'.

Step 6b: Trigger analysis

1
const analyseRes = await fetch(
2
  `/api/bids/${BID_ID}/templates/${TEMPLATE_ID}/analyse`,
3
  {
4
    method: 'POST',
5
    headers: { 'Content-Type': 'application/json' },
6
    body: JSON.stringify({}),
7
  },
8
);
9
const analyseJob = await analyseRes.json();
10
console.log('Analysis job:', analyseJob);

Expected response: HTTP 202 with { job_id, status: 'queued' }.

The Python worker (bid_worker.py) picks up the job from processing_queue, downloads the template from Supabase Storage, identifies table cells that contain questions, and writes the results to template_fields.

Wait for completion: Poll the template status or watch the worker logs. Analysis typically takes 5-15 seconds.

1
// Poll until status changes from 'analysing'
2
const poll = async () => {
3
  const r = await fetch(`/api/bids/${BID_ID}/templates`);
4
  const { templates } = await r.json();
5
  const t = templates.find((t) => t.id === TEMPLATE_ID);
6
  console.log('Template status:', t?.status, 'Fields:', t?.field_count);
7
  return t?.status;
8
};
9
// Call poll() every few seconds until status is 'analysed'

Step 6c: Auto-map fields to questions

1
const mapRes = await fetch(
2
  `/api/bids/${BID_ID}/templates/${TEMPLATE_ID}/auto-map`,
3
  {
4
    method: 'POST',
5
    headers: { 'Content-Type': 'application/json' },
6
    body: JSON.stringify({ threshold: 0.5 }), // Lower threshold for test data
7
  },
8
);
9
const mapResult = await mapRes.json();
10
console.log(`Mapped ${mapResult.mapped}/${mapResult.total} fields`);

Expected response: { mapped: N, unmapped: M, total: T, mappings: [...] }.

Auto-mapping uses Dice coefficient text similarity (no AI). It matches template field question text against bid question text.

Step 6d: Confirm mappings

After auto-mapping, fields have mapping_status: 'unreviewed'. Confirm them so they are included in the fill:

1
// Fetch the mappings from auto-map result
2
const confirmRes = await fetch(
3
  `/api/bids/${BID_ID}/templates/${TEMPLATE_ID}/fields/bulk-update`,
4
  {
5
    method: 'POST',
6
    headers: { 'Content-Type': 'application/json' },
7
    body: JSON.stringify({
8
      mappings: mapResult.mappings.map((m) => ({
9
        field_id: m.field_id,
10
        question_id: m.question_id,
11
        mapping_status: 'confirmed',
12
      })),
13
    }),
14
  },
15
);
16
const confirmResult = await confirmRes.json();
17
console.log(`Confirmed ${confirmResult.updated} mappings`);

Step 6e: Fill the template

1
const fillRes = await fetch(
2
  `/api/bids/${BID_ID}/templates/${TEMPLATE_ID}/fill`,
3
  {
4
    method: 'POST',
5
    headers: { 'Content-Type': 'application/json' },
6
    body: JSON.stringify({
7
      skip_unmapped: true,
8
      skip_unapproved: false,
9
      fallback_to_draft: true,
10
      response_variant: 'standard',
11
    }),
12
  },
13
);
14
const fillJob = await fillRes.json();
15
console.log('Fill job:', fillJob);

Expected response: HTTP 202 with { job_id, status: 'queued', fields_to_fill: N }.

Wait for completion: The Python worker fills the template by writing response text into the identified table cells, preserving the original formatting. This typically takes 10-30 seconds.

1
// After fill completes, fetch completions
2
const completionsRes = await fetch(`/api/bids/${BID_ID}/templates`);
3
const { templates } = await completionsRes.json();
4
const filled = templates.find((t) => t.id === TEMPLATE_ID);
5
console.log('Template status:', filled?.status);
6
console.log('Completions count:', filled?.completions_count);

Step 6f: Download the completed document

1
// Get the completion ID from template_completions
2
// (The fill job creates a completion record with the filled document)
3
// You can query this via the templates list or directly:
4

5
// First, find the latest completion for this template
6
const tplRes = await fetch(`/api/bids/${BID_ID}/templates`);
7
const { templates: tpls } = await tplRes.json();
8
const tpl = tpls.find((t) => t.id === TEMPLATE_ID);
9

10
// If completions_count > 0, get the download URL
11
// The completion ID is available from the template_completions table
12
// For now, use the UI at /bid/{BID_ID}/templates to download

Verification checklist:

Template analysis identifies the correct number of table cells
Auto-map matches fields to the right questions
Fill completes without errors
Downloaded document has responses in the correct cells
Original formatting (fonts, colours, borders) is preserved
Word limits are respected (truncation warnings if exceeded)

7. AI Boundary Analysis

Understanding where AI is and is not involved helps determine what can be tested without API keys.

Operation	AI involved?	Details
Bid creation	No	Simple CRUD
Question extraction from tender doc	Yes	Claude extracts questions from uploaded documents
Adding questions manually	No	Direct database insert
KB matching	Yes	Uses embeddings for semantic search
Response drafting	Yes	`lib/bid-drafting.ts` calls Claude
Response editing/approval	No	Direct database update
Export DOCX/XLSX	No	Deterministic document generation
Template upload	No	File storage
Template analysis	No	Python `analyse_template.py` — regex/heuristic
Template auto-map	No	Dice coefficient text similarity
Template fill	No	Python `fill_template.py` — python-docx cell writes

Summary: To test the full export and template completion flows, you only need to bypass two AI-dependent steps (question extraction and response drafting) by inserting data directly via SQL.

8. Cleanup

Delete test templates (cleans storage)

1
// Delete via the API (cascades to template_fields, template_completions)
2
await fetch(`/api/bids/${BID_ID}/templates/${TEMPLATE_ID}`, {
3
  method: 'DELETE',
4
});

Delete test bid (cascades to questions and responses)

1
// Requires admin role
2
await fetch(`/api/bids/${BID_ID}`, {
3
  method: 'DELETE',
4
});

The DELETE /api/bids/:id endpoint deletes the project record. Due to cascading foreign keys, this also removes:

bid_questions (via project_id)
bid_responses (via question_id -> bid_questions)
templates (via project_id)
template_fields (via template_id -> templates)
template_completions (via template_id -> templates)

Find remaining test data

1
-- Find any test bids that were not cleaned up
2
SELECT id, name, domain_metadata->>'status' as status, created_at
3
FROM projects
4
WHERE type = 'bid'
5
  AND name LIKE '[E2E Test]%'
6
ORDER BY created_at DESC;
7

8
-- Find orphaned test responses (if questions were deleted but responses remain)
9
SELECT r.id, r.question_id, r.review_status
10
FROM bid_responses r
11
LEFT JOIN bid_questions q ON r.question_id = q.id
12
WHERE q.id IS NULL;
13

14
-- Find test templates
15
SELECT id, name, project_id, status
16
FROM templates
17
WHERE name LIKE '[E2E Test]%';

Storage cleanup

Template files are stored in the templates Supabase Storage bucket. Deleting the template record via the API also removes the storage files. If storage files are orphaned, clean them up manually:

1
-- List storage objects for a specific bid
2
SELECT name, created_at
3
FROM storage.objects
4
WHERE bucket_id = 'templates'
5
  AND name LIKE '<BID_ID>/%';

9. Complete Script: End-to-End Happy Path

This script runs all the steps above in sequence. Paste it into the browser DevTools console while logged in as an admin/editor.

1
// ============================================
2
// E2E Test: Full bid -> export happy path
3
// ============================================
4
// Prerequisites: dev server running, logged in
5

6
(async () => {
7
  const BASE = ''; // relative URLs work in DevTools
8

9
  // 1. Create bid
10
  console.log('Step 1: Creating bid...');
11
  const bidRes = await fetch(`${BASE}/api/bids`, {
12
    method: 'POST',
13
    headers: { 'Content-Type': 'application/json' },
14
    body: JSON.stringify({
15
      name: `[E2E Test] IT Support ${Date.now()}`,
16
      buyer: 'E2E Test Corp',
17
      deadline: new Date(Date.now() + 14 * 86400000)
18
        .toISOString()
19
        .split('T')[0],
20
    }),
21
  });
22
  if (!bidRes.ok) throw new Error(`Create bid failed: ${bidRes.status}`);
23
  const bid = await bidRes.json();
24
  console.log('  Bid ID:', bid.id);
25

26
  // 2. Add questions
27
  console.log('Step 2: Adding questions...');
28
  const qRes = await fetch(`${BASE}/api/bids/${bid.id}/questions`, {
29
    method: 'POST',
30
    headers: { 'Content-Type': 'application/json' },
31
    body: JSON.stringify({
32
      questions: [
33
        {
34
          section_name: 'Technical',
35
          section_sequence: 1,
36
          question_sequence: 1,
37
          question_text:
38
            'Describe your IT support approach and response times.',
39
          word_limit: 500,
40
        },
41
        {
42
          section_name: 'Experience',
43
          section_sequence: 2,
44
          question_sequence: 1,
45
          question_text:
46
            'What public sector IT support experience do you have?',
47
          word_limit: 400,
48
        },
49
        {
50
          section_name: 'Social Value',
51
          section_sequence: 3,
52
          question_sequence: 1,
53
          question_text:
54
            'How will you deliver social value through this contract?',
55
          word_limit: 300,
56
        },
57
        {
58
          section_name: 'Commercial',
59
          section_sequence: 4,
60
          question_sequence: 1,
61
          question_text: 'Provide your pricing model breakdown.',
62
          word_limit: 600,
63
        },
64
      ],
65
    }),
66
  });
67
  if (!qRes.ok) throw new Error(`Add questions failed: ${qRes.status}`);
68
  const { questions } = await qRes.json();
69
  console.log(`  Created ${questions.length} questions`);
70

71
  // 3. Advance state: draft -> questions_extracted -> matching -> drafting
72
  console.log('Step 3: Advancing bid state...');
73
  for (const status of ['questions_extracted', 'matching', 'drafting']) {
74
    const r = await fetch(`${BASE}/api/bids/${bid.id}`, {
75
      method: 'PATCH',
76
      headers: { 'Content-Type': 'application/json' },
77
      body: JSON.stringify({ status }),
78
    });
79
    if (!r.ok)
80
      throw new Error(`State transition to ${status} failed: ${r.status}`);
81
  }
82
  console.log('  Bid now in drafting state');
83

84
  // 4. NOTE: Response insertion requires direct SQL or Supabase MCP
85
  //    See Section 4 of e2e-test-setup.md for the INSERT statements.
86
  //    After inserting responses, continue with steps 5-6 below.
87
  console.log('Step 4: Insert responses via SQL (see runbook Section 4)');
88
  console.log('  Question IDs for SQL:');
89
  questions.forEach((q, i) => console.log(`    Q${i + 1}: ${q.id}`));
90

91
  // 5. After responses are inserted, advance to ready_for_export
92
  // Uncomment the following once responses exist:
93
  /*
94
  for (const status of ['in_review', 'ready_for_export']) {
95
    await fetch(`${BASE}/api/bids/${bid.id}`, {
96
      method: 'PATCH',
97
      headers: { 'Content-Type': 'application/json' },
98
      body: JSON.stringify({ status })
99
    });
100
  }
101
  console.log('  Bid ready for export');
102

103
  // 6. Export DOCX
104
  console.log('Step 6: Exporting DOCX...');
105
  const docxRes = await fetch(`${BASE}/api/bids/${bid.id}/export/docx`, {
106
    method: 'POST',
107
    headers: { 'Content-Type': 'application/json' },
108
    body: JSON.stringify({})
109
  });
110
  if (!docxRes.ok) throw new Error(`DOCX export failed: ${docxRes.status}`);
111
  const blob = await docxRes.blob();
112
  console.log(`  DOCX generated: ${(blob.size / 1024).toFixed(1)} KB`);
113

114
  // Download it
115
  const url = URL.createObjectURL(blob);
116
  const a = document.createElement('a');
117
  a.href = url;
118
  a.download = 'e2e-test-export.docx';
119
  a.click();
120
  URL.revokeObjectURL(url);
121
  console.log('  Download triggered');
122
  */
123

124
  console.log('\nDone! Bid ID for cleanup:', bid.id);
125
})();

10. Future: Automated E2E with Playwright

When automated E2E tests are implemented, the test data setup described here will serve as the seed script. Key considerations:

Supabase service role client can insert responses directly without auth cookies, bypassing RLS
Playwright fixtures can wrap the create/cleanup cycle in beforeAll/afterAll
AI mocking: The only AI boundary is lib/bid-drafting.ts (generateBidResponse). Mocking this function with static responses enables fully deterministic E2E tests including the drafting flow
Template analysis and filling are already deterministic (Python worker uses regex/heuristics, not AI)
Export generation is already deterministic (docx/xlsx library calls)

11. Test User Provisioning (rebuild flow)

E2E tests require three test users in auth.users and public.user_roles before the suite runs. e2e/global-setup.ts hard-fails if any are missing or have the wrong role.

Required env vars

1
TEST_USER_1_PASSWORD=<password for admin>
2
TEST_USER_2_PASSWORD=<password for editor>
3
TEST_USER_3_PASSWORD=<password for viewer>

These are already set in .env/.env.local for the live project. For new demo or Phew DB rebuilds, generate fresh passwords and add them to the new project’s secrets store.

Provisioning command

1
bun run seed:e2e-users              # provision or verify all 3 users
2
bun run seed:e2e-users --check      # verify-only, exit 1 on mismatch
3
bun run seed:e2e-users --dry-run    # preview without writing

The script uses supabase.auth.admin.createUser() (NOT raw SQL) so the resulting auth.users rows have the correct GoTrue shape — token columns initialised to '', accompanying auth.identities rows. This is the same gotcha that caused the S156 incident with the pipeline service account.

When to run it

After supabase db reset && supabase db push on a fresh project
Before the first bun run test:e2e on any new environment
As part of the demo DB / Phew re-ingest rebuild runbook
Whenever bun run test:e2e fails with “test users not found in auth.users”

The script is idempotent — running it on an environment where users already exist is a no-op aside from re-asserting the role assignments.

Manual fallback

If seed:e2e-users cannot run (e.g. service key not available), the operator can create the three users manually via the Supabase dashboard:

Authentication → Users → Add user (NOT raw SQL — use the UI)
Set the email + a password matching TEST_USER_N_PASSWORD

After all three exist, run this SQL to assign roles:

1
INSERT INTO public.user_roles (user_id, role)
2
SELECT id, CASE
3
  WHEN email = 'test.user1@test-kb-aish.co.uk' THEN 'admin'
4
  WHEN email = 'test.user2@test-kb-aish.co.uk' THEN 'editor'
5
  WHEN email = 'test.user3@test-kb-aish.co.uk' THEN 'viewer'
6
END
7
FROM auth.users
8
WHERE email IN (
9
  'test.user1@test-kb-aish.co.uk',
10
  'test.user2@test-kb-aish.co.uk',
11
  'test.user3@test-kb-aish.co.uk'
12
)
13
ON CONFLICT (user_id) DO UPDATE SET role = EXCLUDED.role;

Generated: Session 46, 5 March 2026 Updated: Session 156, 8 April 2026 — added §11 test user provisioning

E2E Test Data Setup Runbook

E2E Test Data Setup Runbook

1. Prerequisites

Environment variables

2. Test Data Strategy

Naming convention

Differentiation from client data

3. Creating a Test Bid

Step 3a: Create the bid

Step 3b: Add questions (batch)

Step 3c: Advance bid state to drafting

4. Creating Responses WITHOUT AI

Option A: Direct SQL (via Supabase MCP or Dashboard)

Option B: Via API (if you want responses visible in the response editor)

Step 4b: Approve responses via API

Step 4c: Advance to ready_for_export

5. Running Flow 6: Export

Export as DOCX

Export as XLSX

Export options

6. Running Flow 7: Template Completion

Step 6a: Upload a template

Step 6b: Trigger analysis

Step 6c: Auto-map fields to questions

Step 6d: Confirm mappings

Step 6e: Fill the template

Step 6f: Download the completed document

7. AI Boundary Analysis

8. Cleanup

Delete test templates (cleans storage)

Delete test bid (cascades to questions and responses)

Find remaining test data

Storage cleanup

9. Complete Script: End-to-End Happy Path

10. Future: Automated E2E with Playwright

11. Test User Provisioning (rebuild flow)

Required env vars

Provisioning command

When to run it

Manual fallback

Step 3c: Advance bid state to `drafting`

Step 4c: Advance to `ready_for_export`