Quelle test_cache_split.html Sprache: HTML

products/sources/formale Sprachen/C/Firefox/dom/security/test/general/test_cache_split.html

<!DOCTYPE HTML>
<html>

<head>
    <meta charset="utf-8">
    <title>Bug 1454721 - Add same-site cookie test for about:blank and about:srcdoc</title>
    <script src="/tests/SimpleTest/SimpleTest.js"></script>
    <script src="/tests/SimpleTest/ChromeTask.js"></script>
    <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
</head>

<body>
    <img id="cookieImage">
    <script class="testbody" type="text/javascript">
        SimpleTest.requestLongerTimeout(2);

        const CROSS_ORIGIN = "http://mochi.test:8888/";
        const SAME_ORIGIN= "https://example.com/";
        const PATH = "file_cache_splitting_server.sjs";

        async function getCount() {
            return fetch(`${PATH}?state`).then(r => r.text());
        }
        async function resetCount() {
            return fetch(`${PATH}?flush`).then(r => r.text());
        }
        async function ensureLoaded() {
            // This Fetch is geting the Response "1", once file_cache_splitting_isloaded
            // gets a request without a query String issued from the cache_splitting_window.html
            info("Waiting for Pageload");
            let result = await fetch("file_cache_splitting_isloaded.sjs?wait").then(r => r.text);
            info("Page has been Loaded");
            return result;
        }

        async function openAndLoadWindow(origin) {
            let isLoaded =  ensureLoaded();
            let url = `${origin}tests/dom/security/test/general/file_cache_splitting_window.html`;
            let w = window.open(url);
            // let ew = SpecialPowers.wrap(w);
            await isLoaded;
            return w;
        }

        async function checkStep(step = [SAME_ORIGIN, 1], name) {
            info(`Doing Step ${JSON.stringify(step)}`);
            let url = step[0];
            let should_count = step[1];
            let w = await openAndLoadWindow(url);
            let count = await getCount();
            ok(
                count == should_count,
                `${name} req to: ${
                url == SAME_ORIGIN ? "Same Origin" : "Cross Origin"
                } expected ${should_count} request to Server, got ${count}`
            );
            w.close()
        }
        async function clearCache(){
            info("Clearing Cache");
            SpecialPowers.DOMWindowUtils.clearSharedStyleSheetCache();
            await ChromeTask.spawn(null,(()=>{
                Services.cache2.clear();
            }));
        }
        async function runTest(test) {
            info(`Starting Job with - ${test.steps.length} - Requests`);
            await resetCount();
            let { prefs, steps, name } = test;
            await SpecialPowers.pushPrefEnv(prefs);
            for (let step of steps) {
                await checkStep(step, name);
            }
            await clearCache();
        };

        add_task(
            async () =>
                runTest({
                    name: `Isolated Cache`,
                    steps: [[SAME_ORIGIN, 1], [SAME_ORIGIN, 1], [CROSS_ORIGIN, 2]],
                    prefs: {
                        set: [
                            ["privacy.partition.network_state", true]
                        ],
                    },
                })
        );
        // Negative Test: The CROSS_ORIGIN should be able to
        // acess the cache of SAME_ORIGIN
        add_task(
            async () =>
                runTest({
                    name: `Non Isolated Cache`,
                    steps: [[SAME_ORIGIN, 1], [SAME_ORIGIN, 1], [CROSS_ORIGIN, 1]],
                    prefs: {
                        set: [
                            ["privacy.partition.network_state", false]
                        ],
                    },
                })
        );
        // Test that FPI does not affect Cache Isolation
        add_task(
            async () =>
                runTest({
                    name: `FPI interaction`,
                    steps: [[SAME_ORIGIN, 1], [SAME_ORIGIN, 1], [CROSS_ORIGIN, 2]],
                    prefs: {
                        set: [
                            ["privacy.firstparty.isolate", true],
                            ["privacy.partition.network_state", false],
                        ],
                    },
                })
        );
        // Test that cookieBehavior does not affect Cache Isolation
        for (let i = 0; i < SpecialPowers.Ci.nsICookieService.BEHAVIOR_LAST ; i++) {
            add_task(
                async () =>
                    runTest({
                        name: `cookieBehavior interaction ${i}`,
                        steps: [[SAME_ORIGIN, 1], [SAME_ORIGIN, 1], [CROSS_ORIGIN, 2]],
                        prefs: {
                            set: [
                                ["privacy.firstparty.isolate", false],
                                ["network.cookie.cookieBehavior", i],
                                ["privacy.partition.network_state", true],
                            ],
                        },
                    })
            );
        }
        add_task(
            async () =>
                runTest({
                    name: `FPI interaction - 2`,
                    steps: [[SAME_ORIGIN, 1], [SAME_ORIGIN, 1], [CROSS_ORIGIN, 2]],
                    prefs: {
                        set: [
                          ["privacy.firstparty.isolate", true],
                          ["privacy.partition.network_state", false],
                        ],
                    },
                })
        );

    </script>
</body>

</html>

Messung V0.5

¤ Dauer der Verarbeitung: 0.4 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.