summaryrefslogtreecommitdiffstats
path: root/dom/security/test/general/test_cache_split.html
blob: 0696b9f2ca9616474ba30454b3adcbb16a3a7f61 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
<!DOCTYPE HTML>
<html>

<head>
    <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 SAME_ORIGIN = "http://mochi.test:8888/"
        const CROSS_ORIGIN = "http://example.com/";
        const PATH = "file_cache_splitting_server.sjs";

        const Ci = SpecialPowers.Ci;

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

    </script>
</body>

</html>