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
const { Browser, By } = require('selenium-webdriver')
22
const { Pages, suite, ignore } = require('../../lib/test')
23
const BrowsingContext = require('selenium-webdriver/bidi/browsingContext')
24
const until = require('selenium-webdriver/lib/until')
25
const { Origin, CaptureScreenshotParameters } = require('selenium-webdriver/bidi/captureScreenshotParameters')
26
const { BoxClipRectangle, ElementClipRectangle } = require('selenium-webdriver/bidi/clipRectangle')
27
const { CreateContextParameters } = require('selenium-webdriver/bidi/createContextParameters')
28
const BrowserBiDi = require('selenium-webdriver/bidi/browser')
29

30
suite(
31
  function (env) {
32
    let driver
33

34
    beforeEach(async function () {
35
      driver = await env.builder().build()
36
    })
37

38
    afterEach(async function () {
39
      await driver.quit()
40
    })
41

42
    describe('Browsing Context', function () {
43
      let startIndex = 0
44
      let endIndex = 5
45
      let pdfMagicNumber = 'JVBER'
46
      let pngMagicNumber = 'iVBOR'
47

48
      it('can create a browsing context for given id', async function () {
49
        const id = await driver.getWindowHandle()
50
        const browsingContext = await BrowsingContext(driver, {
51
          browsingContextId: id,
52
        })
53
        assert.equal(browsingContext.id, id)
54
      })
55

56
      it('can create a window', async function () {
57
        const browsingContext = await BrowsingContext(driver, {
58
          type: 'window',
59
        })
60
        assert.notEqual(browsingContext.id, null)
61
      })
62

63
      it('can create a window with a reference context', async function () {
64
        const browsingContext = await BrowsingContext(driver, {
65
          type: 'window',
66
          createParameters: new CreateContextParameters().referenceContext(await driver.getWindowHandle()),
67
        })
68
        assert.notEqual(browsingContext.id, null)
69
      })
70

71
      it('can create a tab with all parameters', async function () {
72
        const browser = await BrowserBiDi(driver)
73
        const userContext = await browser.createUserContext()
74
        const browsingContext = await BrowsingContext(driver, {
75
          type: 'window',
76
          createParameters: new CreateContextParameters()
77
            .referenceContext(await driver.getWindowHandle())
78
            .background(true)
79
            .userContext(userContext),
80
        })
81
        assert.notEqual(browsingContext.id, null)
82
        assert.notEqual(browsingContext.id, await driver.getWindowHandle())
83
      })
84

85
      it('can create a tab', async function () {
86
        const browsingContext = await BrowsingContext(driver, {
87
          type: 'tab',
88
        })
89
        assert.notEqual(browsingContext.id, null)
90
      })
91

92
      it('can create a tab with a reference context', async function () {
93
        const browsingContext = await BrowsingContext(driver, {
94
          type: 'tab',
95
          referenceContext: new CreateContextParameters().referenceContext(await driver.getWindowHandle()),
96
        })
97
        assert.notEqual(browsingContext.id, null)
98
      })
99

100
      it('can navigate to a url', async function () {
101
        const browsingContext = await BrowsingContext(driver, {
102
          type: 'tab',
103
        })
104

105
        let info = await browsingContext.navigate(Pages.logEntryAdded)
106

107
        assert.notEqual(browsingContext.id, null)
108
        assert.notEqual(info.navigationId, null)
109
        assert(info.url.includes('/bidi/logEntryAdded.html'))
110
      })
111

112
      it('can navigate to a url with readiness state', async function () {
113
        const browsingContext = await BrowsingContext(driver, {
114
          type: 'tab',
115
        })
116

117
        const info = await browsingContext.navigate(Pages.logEntryAdded, 'complete')
118

119
        assert.notEqual(browsingContext.id, null)
120
        assert.notEqual(info.navigationId, null)
121
        assert(info.url.includes('/bidi/logEntryAdded.html'))
122
      })
123

124
      it('can get tree with a child', async function () {
125
        const browsingContextId = await driver.getWindowHandle()
126
        const parentWindow = await BrowsingContext(driver, {
127
          browsingContextId: browsingContextId,
128
        })
129
        await parentWindow.navigate(Pages.iframePage, 'complete')
130

131
        const contextInfo = await parentWindow.getTree()
132
        assert.equal(contextInfo.children.length, 1)
133
        assert.equal(contextInfo.id, browsingContextId)
134
        assert(contextInfo.children[0]['url'].includes('formPage.html'))
135
      })
136

137
      it('can get tree with depth', async function () {
138
        const browsingContextId = await driver.getWindowHandle()
139
        const parentWindow = await BrowsingContext(driver, {
140
          browsingContextId: browsingContextId,
141
        })
142
        await parentWindow.navigate(Pages.iframePage, 'complete')
143

144
        const contextInfo = await parentWindow.getTree(0)
145
        assert.equal(contextInfo.children, null)
146
        assert.equal(contextInfo.id, browsingContextId)
147
      })
148

149
      it('can close a window', async function () {
150
        const window1 = await BrowsingContext(driver, { type: 'window' })
151
        const window2 = await BrowsingContext(driver, { type: 'window' })
152

153
        await window2.close()
154

155
        assert.doesNotThrow(async function () {
156
          await window1.getTree()
157
        })
158
        await assert.rejects(window2.getTree(), { message: 'no such frame' })
159
      })
160

161
      it('can print PDF with total pages', async function () {
162
        const id = await driver.getWindowHandle()
163
        const browsingContext = await BrowsingContext(driver, {
164
          browsingContextId: id,
165
        })
166

167
        await driver.get(Pages.printPage)
168
        const result = await browsingContext.printPage()
169

170
        let base64Code = result.data.slice(startIndex, endIndex)
171
        assert.strictEqual(base64Code, pdfMagicNumber)
172
      })
173

174
      it('can print PDF with all valid parameters', async function () {
175
        const id = await driver.getWindowHandle()
176
        const browsingContext = await BrowsingContext(driver, {
177
          browsingContextId: id,
178
        })
179

180
        await driver.get(Pages.printPage)
181
        const result = await browsingContext.printPage({
182
          orientation: 'landscape',
183
          scale: 1,
184
          background: true,
185
          width: 30,
186
          height: 30,
187
          top: 1,
188
          bottom: 1,
189
          left: 1,
190
          right: 1,
191
          shrinkToFit: true,
192
          pageRanges: ['1-2'],
193
        })
194

195
        let base64Code = result.data.slice(startIndex, endIndex)
196
        assert.strictEqual(base64Code, pdfMagicNumber)
197
      })
198

199
      it('can take screenshot', async function () {
200
        const id = await driver.getWindowHandle()
201
        const browsingContext = await BrowsingContext(driver, {
202
          browsingContextId: id,
203
        })
204

205
        const response = await browsingContext.captureScreenshot()
206
        const base64code = response.slice(startIndex, endIndex)
207
        assert.equal(base64code, pngMagicNumber)
208
      })
209

210
      it('can take screenshot with all parameters for box screenshot', async function () {
211
        const id = await driver.getWindowHandle()
212
        const browsingContext = await BrowsingContext(driver, {
213
          browsingContextId: id,
214
        })
215

216
        let captureScreenshotParams = new CaptureScreenshotParameters()
217
        captureScreenshotParams.origin(Origin.VIEWPORT).clipRectangle(new BoxClipRectangle(5, 5, 10, 10))
218

219
        const response = await browsingContext.captureScreenshot(captureScreenshotParams)
220

221
        const base64code = response.slice(startIndex, endIndex)
222
        assert.equal(base64code, pngMagicNumber)
223
      })
224

225
      it('can take screenshot with all parameters for element screenshot', async function () {
226
        const id = await driver.getWindowHandle()
227
        const browsingContext = await BrowsingContext(driver, {
228
          browsingContextId: id,
229
        })
230

231
        await driver.get(Pages.formPage)
232
        const element = await driver.findElement(By.id('checky'))
233
        const elementId = await element.getId()
234

235
        let captureScreenshotParams = new CaptureScreenshotParameters()
236
        captureScreenshotParams.origin(Origin.VIEWPORT).clipRectangle(new ElementClipRectangle(elementId))
237

238
        const response = await browsingContext.captureScreenshot(captureScreenshotParams)
239

240
        const base64code = response.slice(startIndex, endIndex)
241
        assert.equal(base64code, pngMagicNumber)
242
      })
243

244
      it('can take box screenshot', async function () {
245
        const id = await driver.getWindowHandle()
246
        const browsingContext = await BrowsingContext(driver, {
247
          browsingContextId: id,
248
        })
249

250
        const response = await browsingContext.captureBoxScreenshot(5, 5, 10, 10)
251

252
        const base64code = response.slice(startIndex, endIndex)
253
        assert.equal(base64code, pngMagicNumber)
254
      })
255

256
      it('can take element screenshot', async function () {
257
        const id = await driver.getWindowHandle()
258
        const browsingContext = await BrowsingContext(driver, {
259
          browsingContextId: id,
260
        })
261

262
        await driver.get(Pages.formPage)
263
        const element = await driver.findElement(By.id('checky'))
264
        const elementId = await element.getId()
265
        const response = await browsingContext.captureElementScreenshot(elementId)
266

267
        const base64code = response.slice(startIndex, endIndex)
268
        assert.equal(base64code, pngMagicNumber)
269
      })
270

271
      it('can activate a browsing context', async function () {
272
        const id = await driver.getWindowHandle()
273
        const window1 = await BrowsingContext(driver, {
274
          browsingContextId: id,
275
        })
276

277
        await BrowsingContext(driver, {
278
          type: 'window',
279
        })
280

281
        const result = await driver.executeScript('return document.hasFocus();')
282

283
        assert.equal(result, false)
284

285
        await window1.activate()
286
        const result2 = await driver.executeScript('return document.hasFocus();')
287

288
        assert.equal(result2, true)
289
      })
290

291
      it('can handle user prompt', async function () {
292
        const id = await driver.getWindowHandle()
293
        const browsingContext = await BrowsingContext(driver, {
294
          browsingContextId: id,
295
        })
296

297
        await driver.get(Pages.alertsPage)
298

299
        await driver.findElement(By.id('alert')).click()
300

301
        await driver.wait(until.alertIsPresent())
302

303
        await browsingContext.handleUserPrompt()
304

305
        const result = await driver.getTitle()
306

307
        assert.equal(result, 'Testing Alerts')
308
      })
309

310
      it('can accept user prompt', async function () {
311
        const id = await driver.getWindowHandle()
312
        const browsingContext = await BrowsingContext(driver, {
313
          browsingContextId: id,
314
        })
315

316
        await driver.get(Pages.alertsPage)
317

318
        await driver.findElement(By.id('alert')).click()
319

320
        await driver.wait(until.alertIsPresent())
321

322
        await browsingContext.handleUserPrompt(true)
323

324
        const result = await driver.getTitle()
325

326
        assert.equal(result, 'Testing Alerts')
327
      })
328

329
      it('can dismiss user prompt', async function () {
330
        const id = await driver.getWindowHandle()
331
        const browsingContext = await BrowsingContext(driver, {
332
          browsingContextId: id,
333
        })
334

335
        await driver.get(Pages.alertsPage)
336

337
        await driver.findElement(By.id('alert')).click()
338

339
        await driver.wait(until.alertIsPresent())
340

341
        await browsingContext.handleUserPrompt(false)
342

343
        const result = await driver.getTitle()
344

345
        assert.equal(result, 'Testing Alerts')
346
      })
347

348
      it('can pass user text to user prompt', async function () {
349
        const id = await driver.getWindowHandle()
350
        const browsingContext = await BrowsingContext(driver, {
351
          browsingContextId: id,
352
        })
353

354
        await driver.get(Pages.userpromptPage)
355

356
        await driver.findElement(By.id('alert')).click()
357

358
        await driver.wait(until.alertIsPresent())
359

360
        const userText = 'Selenium automates browsers'
361

362
        await browsingContext.handleUserPrompt(undefined, userText)
363

364
        const result = await driver.getPageSource()
365
        assert.equal(result.includes(userText), true)
366
      })
367

368
      it('can accept user prompt with user text', async function () {
369
        const id = await driver.getWindowHandle()
370
        const browsingContext = await BrowsingContext(driver, {
371
          browsingContextId: id,
372
        })
373

374
        await driver.get(Pages.userpromptPage)
375

376
        await driver.findElement(By.id('alert')).click()
377

378
        await driver.wait(until.alertIsPresent())
379

380
        const userText = 'Selenium automates browsers'
381

382
        await browsingContext.handleUserPrompt(true, userText)
383

384
        const result = await driver.getPageSource()
385
        assert.equal(result.includes(userText), true)
386
      })
387

388
      it('can dismiss user prompt with user text', async function () {
389
        const id = await driver.getWindowHandle()
390
        const browsingContext = await BrowsingContext(driver, {
391
          browsingContextId: id,
392
        })
393

394
        await driver.get(Pages.userpromptPage)
395

396
        await driver.findElement(By.id('alert')).click()
397

398
        await driver.wait(until.alertIsPresent())
399

400
        const userText = 'Selenium automates browsers'
401

402
        await browsingContext.handleUserPrompt(false, userText)
403

404
        const result = await driver.getPageSource()
405
        assert.equal(result.includes(userText), false)
406
      })
407

408
      xit('can reload a browsing context', async function () {
409
        const id = await driver.getWindowHandle()
410
        const browsingContext = await BrowsingContext(driver, {
411
          browsingContextId: id,
412
        })
413

414
        const result = await browsingContext.navigate(Pages.logEntryAdded, 'complete')
415

416
        await browsingContext.reload()
417
        assert.equal(result.navigationId, null)
418
        assert(result.url.includes('/bidi/logEntryAdded.html'))
419
      })
420

421
      it('can reload with readiness state', async function () {
422
        const id = await driver.getWindowHandle()
423
        const browsingContext = await BrowsingContext(driver, {
424
          browsingContextId: id,
425
        })
426

427
        const result = await browsingContext.navigate(Pages.logEntryAdded, 'complete')
428

429
        await browsingContext.reload(undefined, 'complete')
430
        assert.notEqual(result.navigationId, null)
431
        assert(result.url.includes('/bidi/logEntryAdded.html'))
432
      })
433

434
      it('can set viewport', async function () {
435
        const id = await driver.getWindowHandle()
436
        const browsingContext = await BrowsingContext(driver, {
437
          browsingContextId: id,
438
        })
439

440
        await driver.get(Pages.blankPage)
441

442
        await browsingContext.setViewport(250, 300)
443

444
        const result = await driver.executeScript('return [window.innerWidth, window.innerHeight];')
445
        assert.equal(result[0], 250)
446
        assert.equal(result[1], 300)
447
      })
448

449
      ignore(env.browsers(Browser.FIREFOX)).it('can set viewport with device pixel ratio', async function () {
450
        const id = await driver.getWindowHandle()
451
        const browsingContext = await BrowsingContext(driver, {
452
          browsingContextId: id,
453
        })
454

455
        await driver.get(Pages.blankPage)
456

457
        await browsingContext.setViewport(250, 300, 5)
458

459
        const result = await driver.executeScript('return [window.innerWidth, window.innerHeight];')
460
        assert.equal(result[0], 250)
461
        assert.equal(result[1], 300)
462

463
        const devicePixelRatio = await driver.executeScript('return window.devicePixelRatio;')
464
        assert.equal(devicePixelRatio, 5)
465
      })
466

467
      it('Get All Top level browsing contexts', async () => {
468
        const id = await driver.getWindowHandle()
469
        const window1 = await BrowsingContext(driver, {
470
          browsingContextId: id,
471
        })
472

473
        await BrowsingContext(driver, { type: 'window' })
474

475
        const res = await window1.getTopLevelContexts()
476
        assert.equal(res.length, 2)
477
      })
478
    })
479
  },
480
  { browsers: [Browser.FIREFOX, Browser.CHROME, Browser.EDGE] },
481
)
482

483