[Feature]is it possible to reuse static resouces cache of previous test run ?

[Jabbar2010]

Test Case 1 :
new context()
page.goto("https://example.com");

Test Case 2
new context()
page.goto("https://example.com");

I want to reuse all the static resource cache from Test Case 1 in Test Case 2, so that this test case will not download the resources anymore, it will be very useful when it accesses some websites with large file resources

In Isolation mode, Is there a way to achieve it?
PS: Just want to reuse the static resources not cookies or storage.

[pavelfeldman]

We don't share the disk cache between the isolated contexts. Leaving this open to collect more upvotes.

[Jabbar2010]

Pavel Feldman (@pavelfeldman) Hi, is there another way to achieve it and reuse the disk cache?

[pavelfeldman]

Not at this point. Using caching HTTP proxy would solve it, but I get how it is somewhat hard to set up.

[rolandz83]

This would be an useful feature to have and I've been asked about reducing the number of calls on our test server which we are running our test against, 600+ test cases all requesting the same resource over and over again. mocking and interception is used in some cases but majority of the time pages require script bundles to work properly, reusing them would be fantastic.

[Jabbar2010]

This would be an useful feature to have and I've been asked about reducing the number of calls on our test server which we are running our test against, 600+ test cases all requesting the same resource over and over again. mocking and interception is used in some cases but majority of the time pages require script bundles to work properly, reusing them would be fantastic.

Agree

[pastelsky]

Disk/memory resource caching can speed up tests quite a bit — and this is especially true for VR tests where page load might often be the most time-consuming task.

Pavel Feldman (@pavelfeldman) I can share some stats on how much of a difference this can make with a large internal test suite. Could you please point me to how and where I can go about (temporarily) make this change — in case it doesn't need a large overhaul of things.

[drRobertDev]

should be good to implement it. why waste network resources to redownload something you have in other context.

[statyan]

As we already have something like page.context() to persist and share between contexts, could be there a similar concept of sharing loaded resources ? Like integrate service worker to respond for these calls or something..

[thomas-colgrove]

This would probably make my tests 3x faster - currently its almost faster to run them in serial mode to avoid disk cache penalty.

[uptickmetachu]

We've rewritten our tests to not use the playwright testing framework and instead use cucumber.js

Reusing a page context between tests (while still maintaining test isolation via some backend specific multitenancy/postgres tricks) made our tests much, much, much faster.

[xoewrl]

Not at this point. Using caching HTTP proxy would solve it, but I get how it is somewhat hard to set up.

A workaround using Route

import { md5 } from 'js-md5';
import fs from 'fs'
import path from "path";
import child_process from 'child_process'
import util from 'util';
const exec = util.promisify(child_process.exec);

async function runCommand(command) {
    await exec(command, function () {})
}
runCommand('npx http-server').then();
await new Promise(resolve => setTimeout(resolve, 5000))
console.log("Local Proxy Started!")

function get_url_extension( url ) {
    return url.split(/[#?]/)[0].split('.').pop().trim();
}
const cacheDir = ".cache_static"
const cacheFunc = async (route, request) => {
    let url = request.url()
    let fileType = get_url_extension(url)
    let hash = md5(url) + "." + fileType
    if (!fs.existsSync(path.join(cacheDir, hash))) {
        console.log("[miss]",url, hash)
        const r0 = await route.fetch();
        const body = await r0.body()
        fs.writeFileSync(path.join(cacheDir, hash), body);
    }
    const response = await route.fetch({url:`http://127.0.0.1:8080/${cacheDir}/${hash}`})
    await route.fulfill({response})

}

 ....

await page.route('**/*.css', cacheFunc)
await page.route('**/*.png', cacheFunc)
await page.route('**/*.woff2', cacheFunc)
await page.route('**/*.gif', cacheFunc)
await page.route('**/*.js', cacheFunc)
await page.route('**/*.webp', cacheFunc)
await page.goto('https://github.com', { waitUntil: 'load' })

[bysiber]

+1 for cache reuse across test runs. Playwright's browser binaries + test artifacts can consume several GB, especially in CI where fresh installs happen on every run.

On local macOS development, Playwright browsers are cached at ~/Library/Caches/ms-playwright/ and can grow to 1-3GB per browser version. Combined with other dev caches (node_modules, Docker, Xcode DerivedData, Homebrew), it adds up fast.

For anyone looking to audit and manage these caches locally, I built ClearDisk a free, open-source macOS menu bar utility that monitors 44+ developer cache paths and shows size breakdowns at a glance. Useful for keeping disk space healthy when working with multiple heavy toolchains.

# Quick check of Playwright cache size
du -sh ~/Library/Caches/ms-playwright/ 2>/dev/null

# Remove old browser versions (keeps latest)
npx playwright install --with-deps