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 } = require('selenium-webdriver')
22
const { Pages, suite, ignore } = require('../../lib/test')
23
const { Network, CacheBehavior } = require('selenium-webdriver/bidi/network')
24
const BrowsingContext = require('selenium-webdriver/bidi/browsingContext')
25
const until = require('selenium-webdriver/lib/until')
26

27
suite(
28
  function (env) {
29
    let driver
30
    let network
31

32
    beforeEach(async function () {
33
      driver = await env.builder().build()
34
      network = await Network(driver)
35
    })
36

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

42
    describe('Network network', function () {
43
      it('can listen to event before request is sent', async function () {
44
        let beforeRequestEvent = null
45
        await network.beforeRequestSent(function (event) {
46
          if (event.request.url.includes('empty')) {
47
            beforeRequestEvent = event
48
          }
49
        })
50

51
        await driver.get(Pages.emptyPage)
52

53
        assert.equal(beforeRequestEvent.request.method, 'GET')
54
        const url = beforeRequestEvent.request.url
55
        assert.equal(url, await driver.getCurrentUrl())
56
      })
57

58
      it('can request cookies', async function () {
59
        let beforeRequestEvent = null
60
        await network.beforeRequestSent(function (event) {
61
          beforeRequestEvent = event
62
        })
63

64
        await driver.get(Pages.emptyText)
65
        await driver.manage().addCookie({
66
          name: 'north',
67
          value: 'biryani',
68
        })
69
        await driver.navigate().refresh()
70

71
        assert.equal(beforeRequestEvent.request.method, 'GET')
72
        assert.equal(beforeRequestEvent.request.cookies[0].name, 'north')
73
        assert.equal(beforeRequestEvent.request.cookies[0].value.value, 'biryani')
74
        const url = beforeRequestEvent.request.url
75
        assert.equal(url, await driver.getCurrentUrl())
76

77
        await driver.manage().addCookie({
78
          name: 'south',
79
          value: 'dosa',
80
        })
81
        await driver.navigate().refresh()
82

83
        assert.equal(beforeRequestEvent.request.cookies[1].name, 'south')
84
        assert.equal(beforeRequestEvent.request.cookies[1].value.value, 'dosa')
85
      })
86

87
      ignore(env.browsers(Browser.CHROME, Browser.EDGE)).it('can redirect http equiv', async function () {
88
        let beforeRequestEvent = []
89
        await network.beforeRequestSent(function (event) {
90
          beforeRequestEvent.push(event)
91
        })
92

93
        await driver.get(Pages.redirectedHttpEquiv)
94
        await driver.wait(until.urlContains('redirected.html'), 1000)
95

96
        assert.equal(beforeRequestEvent[0].request.method, 'GET')
97
        assert(beforeRequestEvent[0].request.url.includes('redirected_http_equiv.html'))
98
        assert.equal(beforeRequestEvent[2].request.method, 'GET')
99
        assert(beforeRequestEvent[2].request.url.includes('redirected.html'))
100
      })
101

102
      it('can subscribe to response started', async function () {
103
        let onResponseStarted = []
104
        await network.responseStarted(function (event) {
105
          onResponseStarted.push(event)
106
        })
107

108
        await driver.get(Pages.emptyText)
109

110
        assert.equal(onResponseStarted[0].request.method, 'GET')
111
        assert.equal(onResponseStarted[0].request.url, await driver.getCurrentUrl())
112
        assert.equal(onResponseStarted[0].response.url, await driver.getCurrentUrl())
113
        assert.equal(onResponseStarted[0].response.fromCache, false)
114
        assert(onResponseStarted[0].response.mimeType.includes('text/plain'))
115
        assert.equal(onResponseStarted[0].response.status, 200)
116
        assert.equal(onResponseStarted[0].response.statusText, 'OK')
117
      })
118

119
      it('test response started mime type', async function () {
120
        let onResponseStarted = []
121
        await network.responseStarted(function (event) {
122
          onResponseStarted.push(event)
123
        })
124

125
        // Checking mime type for 'html' text
126
        await driver.get(Pages.emptyPage)
127
        assert.equal(onResponseStarted[0].request.method, 'GET')
128
        assert.equal(onResponseStarted[0].request.url, await driver.getCurrentUrl())
129
        assert.equal(onResponseStarted[0].response.url, await driver.getCurrentUrl())
130
        assert(onResponseStarted[0].response.mimeType.includes('text/html'))
131

132
        // Checking mime type for 'plain' text
133
        onResponseStarted = []
134
        await driver.get(Pages.emptyText)
135
        assert.equal(onResponseStarted[0].response.url, await driver.getCurrentUrl())
136
        assert(onResponseStarted[0].response.mimeType.includes('text/plain'))
137
      })
138

139
      it('can subscribe to response completed', async function () {
140
        let onResponseCompleted = []
141
        await network.responseCompleted(function (event) {
142
          onResponseCompleted.push(event)
143
        })
144

145
        await driver.get(Pages.emptyPage)
146

147
        assert.equal(onResponseCompleted[0].request.method, 'GET')
148
        assert.equal(onResponseCompleted[0].request.url, await driver.getCurrentUrl())
149
        assert.equal(onResponseCompleted[0].response.url, await driver.getCurrentUrl())
150
        assert.equal(onResponseCompleted[0].response.fromCache, false)
151
        assert(onResponseCompleted[0].response.mimeType.includes('text/html'))
152
        assert.equal(onResponseCompleted[0].response.status, 200)
153
        assert.equal(onResponseCompleted[0].response.statusText, 'OK')
154
        assert.equal(onResponseCompleted[0].redirectCount, 0)
155
      })
156

157
      ignore(env.browsers(Browser.CHROME, Browser.EDGE)).it('can listen to auth required event', async function () {
158
        let authRequiredEvent = null
159
        await network.authRequired(function (event) {
160
          authRequiredEvent = event
161
        })
162

163
        await driver.get(Pages.basicAuth)
164

165
        const url = authRequiredEvent.request.url
166
        assert.equal(authRequiredEvent.id, await driver.getWindowHandle())
167
        assert.equal(authRequiredEvent.request.method, 'GET')
168
        assert.equal(url.includes('basicAuth'), true)
169

170
        assert.equal(authRequiredEvent.response.status, 401)
171
        assert.equal(authRequiredEvent.response.headers.length > 1, true)
172
        assert.equal(authRequiredEvent.response.url.includes('basicAuth'), true)
173
      })
174

175
      it('can listen to fetch error event', async function () {
176
        let fetchErrorEvent = null
177
        await network.fetchError(function (event) {
178
          fetchErrorEvent = event
179
        })
180

181
        try {
182
          await driver.get('https://not_a_valid_url.test/')
183
          /*eslint no-unused-vars: "off"*/
184
        } catch (e) {
185
          // ignore
186
        }
187

188
        const url = fetchErrorEvent.request.url
189
        assert.equal(fetchErrorEvent.id, await driver.getWindowHandle())
190
        assert.equal(fetchErrorEvent.request.method, 'GET')
191
        assert.equal(url.includes('valid_url'), true)
192
        assert.equal(fetchErrorEvent.request.headers.length > 1, true)
193
        assert.notEqual(fetchErrorEvent.errorText, null)
194
      })
195

196
      it('test response completed mime type', async function () {
197
        let onResponseCompleted = []
198
        await network.responseCompleted(function (event) {
199
          onResponseCompleted.push(event)
200
        })
201

202
        // Checking mime type for 'html' text
203
        await driver.get(Pages.emptyPage)
204
        assert.equal(onResponseCompleted[0].request.method, 'GET')
205
        assert.equal(onResponseCompleted[0].request.url, await driver.getCurrentUrl())
206
        assert.equal(onResponseCompleted[0].response.url, await driver.getCurrentUrl())
207
        assert(onResponseCompleted[0].response.mimeType.includes('text/html'))
208

209
        // Checking mime type for 'plain' text
210
        onResponseCompleted = []
211
        await driver.get(Pages.emptyText)
212
        assert.equal(onResponseCompleted[0].response.url, await driver.getCurrentUrl())
213
        assert(onResponseCompleted[0].response.mimeType.includes('text/plain'))
214
      })
215
    })
216

217
    describe('setCacheBehavior', function () {
218
      it('can set cache behavior to bypass for a context', async function () {
219
        await driver.get(Pages.emptyPage)
220
        const browsingContext = await BrowsingContext(driver, {
221
          type: 'tab',
222
        })
223
        const contextId = browsingContext.id
224
        await network.setCacheBehavior(CacheBehavior.BYPASS, [contextId])
225
      })
226

227
      it('can set cache behavior to default for a context', async function () {
228
        await driver.get(Pages.emptyPage)
229
        const browsingContext = await BrowsingContext(driver, {
230
          type: 'tab',
231
        })
232
        const contextId = browsingContext.id
233
        await network.setCacheBehavior(CacheBehavior.DEFAULT, [contextId])
234
      })
235

236
      it('can set cache behavior to default/bypass with no context id', async function () {
237
        await driver.get(Pages.emptyPage)
238
        await network.setCacheBehavior(CacheBehavior.DEFAULT)
239
        await network.setCacheBehavior(CacheBehavior.BYPASS)
240
      })
241

242
      it('throws error for invalid cache behavior', async function () {
243
        await driver.get(Pages.emptyPage)
244
        await assert.rejects(
245
          async () => await network.setCacheBehavior('invalid'),
246
          /Cache behavior must be either "default" or "bypass"/,
247
        )
248
      })
249

250
      it('throws error for invalid context id types', async function () {
251
        await driver.get(Pages.emptyPage)
252
        await assert.rejects(
253
          async () => await network.setCacheBehavior(CacheBehavior.BYPASS, ''),
254
          /Contexts must be an array of non-empty strings/,
255
        )
256
        await assert.rejects(
257
          async () => await network.setCacheBehavior(CacheBehavior.BYPASS, ['', ' ']),
258
          /Contexts must be an array of non-empty strings/,
259
        )
260
      })
261
    })
262
  },
263
  { browsers: [Browser.FIREFOX, Browser.CHROME, Browser.EDGE] },
264
)
265

266