# Instructions

- Following Playwright test failed.
- Explain why, be concise, respect Playwright best practices.
- Provide a snippet of code with the fix, if possible.

# Test info

- Name: tests/ui/entities.spec.ts >> entity browse sort order - quantitative fields >> individuals sorted by total contributions descending
- Location: tests/ui/entities.spec.ts:405:7

# Error details

```
Test timeout of 30000ms exceeded.
```

```
Error: response.json: Test timeout of 30000ms exceeded.
```

# Page snapshot

```yaml
- generic [active] [ref=e1]:
  - link "← Back to Home" [ref=e2] [cursor=pointer]:
    - /url: /
  - banner [ref=e3]:
    - heading "Individual Donors" [level=1] [ref=e4]
    - paragraph [ref=e5]: Contributors to federal campaigns
  - generic [ref=e6]:
    - generic [ref=e7]:
      - textbox "Search individual donors by name, city, employer..." [ref=e8]
      - button "Search" [ref=e9] [cursor=pointer]
    - generic [ref=e10]:
      - generic [ref=e11]:
        - generic [ref=e12]: State
        - combobox "State" [ref=e13]:
          - option "Any" [selected]
          - option "Alabama"
          - option "Alaska"
          - option "Arizona"
          - option "Arkansas"
          - option "California"
          - option "Colorado"
          - option "Connecticut"
          - option "Delaware"
          - option "District of Columbia"
          - option "Florida"
          - option "Georgia"
          - option "Hawaii"
          - option "Idaho"
          - option "Illinois"
          - option "Indiana"
          - option "Iowa"
          - option "Kansas"
          - option "Kentucky"
          - option "Louisiana"
          - option "Maine"
          - option "Maryland"
          - option "Massachusetts"
          - option "Michigan"
          - option "Minnesota"
          - option "Mississippi"
          - option "Missouri"
          - option "Montana"
          - option "Nebraska"
          - option "Nevada"
          - option "New Hampshire"
          - option "New Jersey"
          - option "New Mexico"
          - option "New York"
          - option "North Carolina"
          - option "North Dakota"
          - option "Ohio"
          - option "Oklahoma"
          - option "Oregon"
          - option "Pennsylvania"
          - option "Puerto Rico"
          - option "Rhode Island"
          - option "South Carolina"
          - option "South Dakota"
          - option "Tennessee"
          - option "Texas"
          - option "Utah"
          - option "Vermont"
          - option "Virginia"
          - option "Washington"
          - option "West Virginia"
          - option "Wisconsin"
          - option "Wyoming"
      - generic [ref=e14]:
        - generic [ref=e15]: Gave in cycle
        - group [ref=e16]:
          - generic "Any" [ref=e17] [cursor=pointer]
      - generic [ref=e18]:
        - generic [ref=e19]: Lifetime total
        - combobox "Lifetime total" [ref=e20]:
          - option "Any" [selected]
          - option "$200+"
          - option "$1K+"
          - option "$10K+"
          - option "$100K+"
          - option "$1M+"
      - generic [ref=e21]:
        - generic [ref=e22]: Party lean (giving)
        - combobox "Party lean (giving)" [ref=e23]:
          - option "Any" [selected]
          - option "Strong Democratic (80%+ D)"
          - option "Lean Democratic (60–80% D)"
          - option "Mixed (40–60% D)"
          - option "Lean Republican (60–80% R)"
          - option "Strong Republican (80%+ R)"
      - generic [ref=e24]:
        - generic [ref=e25]: Last gave
        - combobox "Last gave" [ref=e26]:
          - option "Any" [selected]
          - option "In 2025–26"
          - option "Since 2023"
          - option "Since 2021"
          - option "Not since 2020"
      - generic [ref=e27]:
        - generic [ref=e28]: Employer
        - textbox "Employer" [ref=e29]:
          - /placeholder: e.g. Google
      - generic [ref=e30]:
        - generic [ref=e31]: Occupation
        - textbox "Occupation" [ref=e32]:
          - /placeholder: e.g. attorney
      - generic [ref=e33]:
        - generic [ref=e34]: City
        - textbox "City" [ref=e35]:
          - /placeholder: e.g. Austin
      - generic [ref=e36]:
        - generic [ref=e37]: ZIP
        - textbox "ZIP" [ref=e38]:
          - /placeholder: 787 or 78701
      - button "Clear filters" [ref=e40] [cursor=pointer]
    - generic [ref=e41]:
      - heading "All Individual Donors" [level=3] [ref=e43]
      - paragraph [ref=e45]: "Failed to load: 400"
  - main [ref=e46]
```

# Test source

```ts
  274 | 
  275 |     const requestBody = JSON.parse(response.request().postData() || '{}');
  276 |     expect(requestBody.variables?.filter).toContain('office_state:TX');
  277 | 
  278 |     const json = await response.json();
  279 |     const results = json.data?.browseEntities?.results || [];
  280 |     expect(results.length).toBeGreaterThan(0);
  281 |   });
  282 | 
  283 |   test('state profile candidates sorted by total contributions descending', async ({ page }) => {
  284 |     const responsePromise = page.waitForResponse(resp => {
  285 |       if (!resp.url().includes('/api/graphql')) return false;
  286 |       if (resp.request().method() !== 'POST') return false;
  287 |       const body = resp.request().postData() || '';
  288 |       return body.includes('browseEntities');
  289 |     }, { timeout: DATA_LOAD_TIMEOUT });
  290 | 
  291 |     await page.goto(TEXAS_PATH);
  292 |     const response = await responsePromise;
  293 | 
  294 |     const json = await response.json();
  295 |     const results = json.data?.browseEntities?.results || [];
  296 |     expect(results.length).toBeGreaterThan(1);
  297 | 
  298 |     const contributions = results.map((r: { metadata?: string }) => {
  299 |       try {
  300 |         const meta = JSON.parse(r.metadata || '{}');
  301 |         return meta.total_contributions || 0;
  302 |       } catch { return 0; }
  303 |     });
  304 | 
  305 |     for (let i = 1; i < contributions.length; i++) {
  306 |       expect(contributions[i - 1]).toBeGreaterThanOrEqual(contributions[i]);
  307 |     }
  308 |   });
  309 | });
  310 | 
  311 | test.describe('district profile - dynamic candidates', () => {
  312 |   const DISTRICT_PATH = '/districts/tx-10/';
  313 | 
  314 |   test('district profile loads candidates filtered to district', async ({ page }) => {
  315 |     const responsePromise = page.waitForResponse(resp => {
  316 |       if (!resp.url().includes('/api/graphql')) return false;
  317 |       if (resp.request().method() !== 'POST') return false;
  318 |       const body = resp.request().postData() || '';
  319 |       return body.includes('browseEntities');
  320 |     }, { timeout: DATA_LOAD_TIMEOUT });
  321 | 
  322 |     await page.goto(DISTRICT_PATH);
  323 |     const response = await responsePromise;
  324 | 
  325 |     const requestBody = JSON.parse(response.request().postData() || '{}');
  326 |     const filter = requestBody.variables?.filter || '';
  327 |     expect(filter).toContain('office:H');
  328 |     expect(filter).toContain('office_state:TX');
  329 |     expect(filter).toContain('office_district:10');
  330 | 
  331 |     const json = await response.json();
  332 |     const results = json.data?.browseEntities?.results || [];
  333 |     expect(results.length).toBeGreaterThan(0);
  334 |   });
  335 | 
  336 |   test('district profile candidates sorted by total contributions descending', async ({ page }) => {
  337 |     const responsePromise = page.waitForResponse(resp => {
  338 |       if (!resp.url().includes('/api/graphql')) return false;
  339 |       if (resp.request().method() !== 'POST') return false;
  340 |       const body = resp.request().postData() || '';
  341 |       return body.includes('browseEntities');
  342 |     }, { timeout: DATA_LOAD_TIMEOUT });
  343 | 
  344 |     await page.goto(DISTRICT_PATH);
  345 |     const response = await responsePromise;
  346 | 
  347 |     const json = await response.json();
  348 |     const results = json.data?.browseEntities?.results || [];
  349 |     expect(results.length).toBeGreaterThan(1);
  350 | 
  351 |     const contributions = results.map((r: { metadata?: string }) => {
  352 |       try {
  353 |         const meta = JSON.parse(r.metadata || '{}');
  354 |         return meta.total_contributions || 0;
  355 |       } catch { return 0; }
  356 |     });
  357 | 
  358 |     for (let i = 1; i < contributions.length; i++) {
  359 |       expect(contributions[i - 1]).toBeGreaterThanOrEqual(contributions[i]);
  360 |     }
  361 |   });
  362 | });
  363 | 
  364 | // Helper to intercept browseEntities GraphQL response and extract score values
  365 | async function getBrowseScores(page: import('@playwright/test').Page, url: string): Promise<number[]> {
  366 |   const responsePromise = page.waitForResponse(resp => {
  367 |     if (!resp.url().includes('/api/graphql')) return false;
  368 |     if (resp.request().method() !== 'POST') return false;
  369 |     const body = resp.request().postData() || '';
  370 |     return body.includes('browseEntities');
  371 |   }, { timeout: DATA_LOAD_TIMEOUT });
  372 |   await page.goto(url);
  373 |   const response = await responsePromise;
> 374 |   const json = await response.json();
      |                               ^ Error: response.json: Test timeout of 30000ms exceeded.
  375 |   const results = json.data?.browseEntities?.results || [];
  376 |   return results.map((r: { score?: number }) => r.score || 0);
  377 | }
  378 | 
  379 | test.describe('entity browse sort order - quantitative fields', () => {
  380 | 
  381 |   test('candidates sorted by total contributions descending', async ({ page }) => {
  382 |     const scores = await getBrowseScores(page, '/candidates/');
  383 |     expect(scores.length).toBeGreaterThan(1);
  384 |     for (let i = 1; i < scores.length; i++) {
  385 |       expect(scores[i - 1]).toBeGreaterThanOrEqual(scores[i]);
  386 |     }
  387 |   });
  388 | 
  389 |   test('committees sorted by total receipts descending', async ({ page }) => {
  390 |     const scores = await getBrowseScores(page, '/committees/');
  391 |     expect(scores.length).toBeGreaterThan(1);
  392 |     for (let i = 1; i < scores.length; i++) {
  393 |       expect(scores[i - 1]).toBeGreaterThanOrEqual(scores[i]);
  394 |     }
  395 |   });
  396 | 
  397 |   test('vendors sorted by total received descending', async ({ page }) => {
  398 |     const scores = await getBrowseScores(page, '/vendors/');
  399 |     expect(scores.length).toBeGreaterThan(1);
  400 |     for (let i = 1; i < scores.length; i++) {
  401 |       expect(scores[i - 1]).toBeGreaterThanOrEqual(scores[i]);
  402 |     }
  403 |   });
  404 | 
  405 |   test('individuals sorted by total contributions descending', async ({ page }) => {
  406 |     const scores = await getBrowseScores(page, '/individuals/');
  407 |     expect(scores.length).toBeGreaterThan(1);
  408 |     // A stale search index scores every donor 0 and the order means nothing.
  409 |     expect(scores[0], 'top individual donor should have contributions').toBeGreaterThan(0);
  410 |     for (let i = 1; i < scores.length; i++) {
  411 |       expect(scores[i - 1]).toBeGreaterThanOrEqual(scores[i]);
  412 |     }
  413 |   });
  414 | 
  415 |   test('employers sorted by total employee contributions descending', async ({ page }) => {
  416 |     const scores = await getBrowseScores(page, '/employers/');
  417 |     expect(scores.length).toBeGreaterThan(1);
  418 |     for (let i = 1; i < scores.length; i++) {
  419 |       expect(scores[i - 1]).toBeGreaterThanOrEqual(scores[i]);
  420 |     }
  421 |   });
  422 | });
  423 | 
  424 | test.describe('us.elect.info entity sections - additional index + detail', () => {
  425 | 
  426 |   test('employers section - index and random pages', async ({ page }) => {
  427 |     const indexResponse = await page.goto('/employers/');
  428 |     expect(indexResponse?.status(), '/employers/ should answer 200').toBe(200);
  429 |     await expect(page.locator('h1')).toContainText(/Employers/i);
  430 | 
  431 |     await expect(page.locator('.entity-search-result').first()).toBeVisible({ timeout: DATA_LOAD_TIMEOUT });
  432 | 
  433 |     const links = await page.locator('.entity-search-result').all();
  434 |     expect(links.length).toBeGreaterThan(0);
  435 | 
  436 |     const hrefs = await Promise.all(links.slice(0, 20).map(l => l.getAttribute('href')));
  437 |     const randomLinks = getRandomItems(hrefs.filter(Boolean) as string[], 3);
  438 | 
  439 |     for (const href of randomLinks) {
  440 |       const entityResponse = await page.goto(toRelativePath(href));
  441 |       expect(entityResponse?.status(), `${toRelativePath(href)} should answer 200`).toBe(200);
  442 |       await expect(page.locator('h1')).toBeVisible();
  443 |     }
  444 |   });
  445 | 
  446 |   test('vendors section - index and random pages', async ({ page }) => {
  447 |     const indexResponse = await page.goto('/vendors/');
  448 |     expect(indexResponse?.status(), '/vendors/ should answer 200').toBe(200);
  449 |     await expect(page.locator('h1')).toContainText(/Vendors/i);
  450 | 
  451 |     await expect(page.locator('.entity-search-result').first()).toBeVisible({ timeout: DATA_LOAD_TIMEOUT });
  452 | 
  453 |     const links = await page.locator('.entity-search-result').all();
  454 |     expect(links.length).toBeGreaterThan(0);
  455 | 
  456 |     const hrefs = await Promise.all(links.slice(0, 20).map(l => l.getAttribute('href')));
  457 |     const randomLinks = getRandomItems(hrefs.filter(Boolean) as string[], 3);
  458 | 
  459 |     for (const href of randomLinks) {
  460 |       const entityResponse = await page.goto(toRelativePath(href));
  461 |       expect(entityResponse?.status(), `${toRelativePath(href)} should answer 200`).toBe(200);
  462 |       await expect(page.locator('h1')).toBeVisible();
  463 |     }
  464 |   });
  465 | 
  466 |   test('counties section - index and random detail pages', async ({ page }) => {
  467 |     await page.goto('/counties/');
  468 | 
  469 |     // Map view is default — verify Leaflet map renders with GeoJSON state shapes
  470 |     await expect(page.locator('#map.leaflet-container')).toBeVisible({ timeout: DATA_LOAD_TIMEOUT });
  471 |     await expect(page.locator('#map .leaflet-interactive').first()).toBeVisible({ timeout: DATA_LOAD_TIMEOUT });
  472 |     const shapes = await page.locator('#map .leaflet-interactive').all();
  473 |     expect(shapes.length).toBeGreaterThan(0);
  474 | 
```