1
// Licensed to the Software Freedom Conservancy (SFC) under one
2
// or more contributor license agreements.  See the NOTICE file
3
// distributed with this work for additional information
4
// regarding copyright ownership.  The SFC licenses this file
5
// to you under the Apache License, Version 2.0 (the
6
// "License"); you may not use this file except in compliance
7
// with the License.  You may obtain a copy of the License at
8
//
9
//   http://www.apache.org/licenses/LICENSE-2.0
10
//
11
// Unless required by applicable law or agreed to in writing,
12
// software distributed under the License is distributed on an
13
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
14
// KIND, either express or implied.  See the License for the
15
// specific language governing permissions and limitations
16
// under the License.
17

18
'use strict'
19

20
const assert = require('node:assert')
21
require('../../lib/test/fileserver')
22
const { suite, ignore } = require('../../lib/test')
23
const { Browser } = require('selenium-webdriver')
24
const Storage = require('selenium-webdriver/bidi/storage')
25
const fileserver = require('../../lib/test/fileserver')
26
const { CookieFilter } = require('selenium-webdriver/bidi/cookieFilter')
27
const { BytesValue, SameSite } = require('selenium-webdriver/bidi/networkTypes')
28
const {
29
  BrowsingContextPartitionDescriptor,
30
  StorageKeyPartitionDescriptor,
31
} = require('selenium-webdriver/bidi/partitionDescriptor')
32
const BrowserBiDi = require('selenium-webdriver/bidi/browser')
33
const BrowsingContext = require('selenium-webdriver/bidi/browsingContext')
34
const { CreateContextParameters } = require('selenium-webdriver/bidi/createContextParameters')
35
const { PartialCookie } = require('selenium-webdriver/bidi/partialCookie')
36

37
suite(
38
  function (env) {
39
    describe('BiDi Storage', function () {
40
      let driver
41

42
      beforeEach(async function () {
43
        driver = await env.builder().build()
44
        await driver.get(fileserver.Pages.ajaxyPage)
45
        await driver.manage().deleteAllCookies()
46
        return assertHasCookies()
47
      })
48

49
      afterEach(function () {
50
        return driver.quit()
51
      })
52

53
      it('can get cookie by name', async function () {
54
        const cookie = createCookieSpec()
55

56
        await driver.manage().addCookie(cookie)
57

58
        const cookieFilter = new CookieFilter()
59
          .name(cookie.name)
60
          .value(new BytesValue(BytesValue.Type.STRING, cookie.value))
61

62
        const storage = await Storage(driver)
63
        const result = await storage.getCookies(cookieFilter)
64

65
        assert.strictEqual(result.cookies[0].value.value, cookie.value)
66
      })
67

68
      ignore(env.browsers(Browser.CHROME, Browser.EDGE)).it(
69
        'can get cookie in default user context',
70
        async function () {
71
          const windowHandle = await driver.getWindowHandle()
72
          const cookie = createCookieSpec()
73

74
          await driver.manage().addCookie(cookie)
75

76
          const cookieFilter = new CookieFilter()
77
            .name(cookie.name)
78
            .value(new BytesValue(BytesValue.Type.STRING, cookie.value))
79

80
          await driver.switchTo().newWindow('window')
81

82
          const descriptor = new BrowsingContextPartitionDescriptor(await driver.getWindowHandle())
83

84
          const storage = await Storage(driver)
85
          const resultAfterSwitchingContext = await storage.getCookies(cookieFilter, descriptor)
86

87
          assert.strictEqual(resultAfterSwitchingContext.cookies[0].value.value, cookie.value)
88

89
          await driver.switchTo().window(windowHandle)
90

91
          const descriptorAfterSwitchingBack = new BrowsingContextPartitionDescriptor(await driver.getWindowHandle())
92

93
          const result = await storage.getCookies(cookieFilter, descriptorAfterSwitchingBack)
94

95
          assert.strictEqual(result.cookies[0].value.value, cookie.value)
96

97
          const partitionKey = result.partitionKey
98

99
          assert.notEqual(partitionKey.userContext, null)
100
          assert.notEqual(partitionKey.sourceOrigin, null)
101
          assert.strictEqual(partitionKey.userContext, 'default')
102
        },
103
      )
104

105
      it('can get cookie in a user context', async function () {
106
        const browser = await BrowserBiDi(driver)
107
        const userContext = await browser.createUserContext()
108
        const windowHandle = await driver.getWindowHandle()
109

110
        const cookie = {
111
          name: getRandomString(),
112
          value: 'set',
113
        }
114

115
        const partitionDescriptor = new StorageKeyPartitionDescriptor().userContext(userContext)
116

117
        const storage = await Storage(driver)
118

119
        const cookieDomain = fileserver.getHostName()
120
        const partialCookie = new PartialCookie(
121
          cookie.name,
122
          new BytesValue(BytesValue.Type.STRING, cookie.value),
123
          cookieDomain,
124
        )
125

126
        await storage.setCookie(partialCookie, partitionDescriptor)
127

128
        const cookieFilter = new CookieFilter().name(cookie.name).value(new BytesValue(BytesValue.Type.STRING, 'set'))
129

130
        // Create a new browsing context with the user context
131
        const createParams = new CreateContextParameters().userContext(userContext)
132

133
        const browsingContext = await BrowsingContext(driver, {
134
          type: 'tab',
135
          createParameters: createParams,
136
        })
137

138
        await driver.switchTo().window(browsingContext.id)
139

140
        const result = await storage.getCookies(cookieFilter, partitionDescriptor)
141

142
        assert.strictEqual(result.cookies.length > 0, true, 'Expected at least one cookie')
143
        assert.strictEqual(result.cookies[0].value.value, cookie.value)
144

145
        // Check if cookies were found
146
        assert.strictEqual(result.cookies.length > 0, true, 'Expected at least one cookie')
147
        assert.strictEqual(result.cookies[0].value.value, cookie.value)
148

149
        // Check partitionKey if it exists
150
        if (result.partitionKey) {
151
          const partitionKey = result.partitionKey
152
          assert.notEqual(partitionKey.userContext, null, 'Expected userContext to be non-null')
153
          assert.strictEqual(partitionKey.userContext, userContext, 'Expected userContext to match')
154
        }
155

156
        await driver.switchTo().window(windowHandle)
157

158
        const browsingContextPartitionDescriptor = new BrowsingContextPartitionDescriptor(windowHandle)
159

160
        const resultAfterSwitchingBack = await storage.getCookies(cookieFilter, browsingContextPartitionDescriptor)
161

162
        assert.strictEqual(resultAfterSwitchingBack.cookies.length, 0)
163
      })
164

165
      it('can add cookie', async function () {
166
        const cookie = createCookieSpec()
167

168
        const storage = await Storage(driver)
169

170
        await storage.setCookie(
171
          new PartialCookie(cookie.name, new BytesValue(BytesValue.Type.STRING, cookie.value), fileserver.whereIs('/')),
172
        )
173

174
        const cookieFilter = new CookieFilter()
175
          .name(cookie.name)
176
          .value(new BytesValue(BytesValue.Type.STRING, cookie.value))
177

178
        const result = await storage.getCookies(cookieFilter)
179

180
        assert.strictEqual(result.cookies[0].value.value, cookie.value)
181
      })
182

183
      it('can add and get cookie with all parameters', async function () {
184
        const cookie = createCookieSpec()
185

186
        const storage = await Storage(driver)
187

188
        const now = Date.now()
189
        const oneHourInMillis = 3600 * 1000
190
        const expiry = now + oneHourInMillis
191

192
        const partitionDescriptor = new BrowsingContextPartitionDescriptor(await driver.getWindowHandle())
193

194
        await storage.setCookie(
195
          new PartialCookie(cookie.name, new BytesValue(BytesValue.Type.STRING, cookie.value), fileserver.whereIs('/'))
196
            .path('/ajaxy_page.html')
197
            .size(100)
198
            .httpOnly(true)
199
            .secure(false)
200
            .sameSite(SameSite.LAX)
201
            .expiry(expiry),
202
          partitionDescriptor,
203
        )
204

205
        const cookieFilter = new CookieFilter()
206
          .name(cookie.name)
207
          .value(new BytesValue(BytesValue.Type.STRING, cookie.value))
208

209
        const result = await storage.getCookies(cookieFilter)
210

211
        const resultCookie = result.cookies[0]
212

213
        assert.strictEqual(resultCookie.name, cookie.name)
214
        assert.strictEqual(resultCookie.value.value, cookie.value)
215
        assert.strictEqual(resultCookie.domain.includes('http'), true)
216
        assert.strictEqual(resultCookie.path, '/ajaxy_page.html')
217
        assert.strictEqual(resultCookie.size > 0, true)
218
        assert.strictEqual(resultCookie.httpOnly, true)
219
        assert.strictEqual(resultCookie.secure, false)
220
        assert.strictEqual(resultCookie.sameSite, SameSite.LAX)
221
        assert.notEqual(resultCookie.expires, null)
222
      })
223

224
      it('can get all cookies', async function () {
225
        const cookie1 = createCookieSpec()
226
        const cookie2 = createCookieSpec()
227

228
        await driver.manage().addCookie(cookie1)
229
        await driver.manage().addCookie(cookie2)
230

231
        const storage = await Storage(driver)
232
        const result = await storage.getCookies()
233

234
        assert.strictEqual(result.cookies[0].value.value, cookie1.value)
235
        assert.strictEqual(result.cookies[1].value.value, cookie2.value)
236
      })
237

238
      it('can delete all cookies', async function () {
239
        const cookie1 = createCookieSpec()
240
        const cookie2 = createCookieSpec()
241

242
        await driver.manage().addCookie(cookie1)
243
        await driver.manage().addCookie(cookie2)
244

245
        const storage = await Storage(driver)
246

247
        await storage.deleteCookies(new CookieFilter())
248

249
        const result = await storage.getCookies()
250

251
        assert.strictEqual(result.cookies.length, 0)
252
      })
253

254
      it('can delete cookie by name', async function () {
255
        const cookie1 = createCookieSpec()
256
        const cookie2 = createCookieSpec()
257

258
        const storage = await Storage(driver)
259

260
        await driver.manage().addCookie(cookie1)
261
        await driver.manage().addCookie(cookie2)
262

263
        const result1 = await storage.getCookies(new CookieFilter())
264
        assert.strictEqual(result1.cookies.length, 2)
265

266
        await storage.deleteCookies(new CookieFilter().name(cookie1.name))
267

268
        const result = await storage.getCookies(new CookieFilter())
269

270
        assert.strictEqual(result.cookies.length, 1)
271
      })
272

273
      function createCookieSpec(opt_options) {
274
        let spec = {
275
          name: getRandomString(),
276
          value: getRandomString(),
277
        }
278
        if (opt_options) {
279
          spec = Object.assign(spec, opt_options)
280
        }
281
        return spec
282
      }
283

284
      function assertHasCookies(...expected) {
285
        return driver
286
          .manage()
287
          .getCookies()
288
          .then(function (cookies) {
289
            assert.strictEqual(
290
              cookies.length,
291
              expected.length,
292
              'Wrong # of cookies.' +
293
                '\n  Expected: ' +
294
                JSON.stringify(expected) +
295
                '\n  Was     : ' +
296
                JSON.stringify(cookies),
297
            )
298

299
            const map = buildCookieMap(cookies)
300
            for (let i = 0; i < expected.length; ++i) {
301
              assert.strictEqual(expected[i].value, map[expected[i].name].value)
302
            }
303
          })
304
      }
305

306
      function buildCookieMap(cookies) {
307
        const map = {}
308
        cookies.forEach(function (cookie) {
309
          map[cookie.name] = cookie
310
        })
311
        return map
312
      }
313

314
      function getRandomString() {
315
        const x = 1234567890
316
        return Math.floor(Math.random() * x).toString(36)
317
      }
318
    })
319
  },
320
  { browsers: [Browser.FIREFOX, Browser.CHROME, Browser.EDGE] },
321
)
322

323