[bidi][js] Add script message event (#13153)

Author: pujagani

javascript/node/selenium-webdriver/bidi/protocolType.js

@@ -42,6 +42,7 @@ const NonPrimitiveType = {
   OBJECT: 'object',
   REGULAR_EXPRESSION: 'regexp',
   SET: 'set',
+  CHANNEL: 'channel',
 
   findByName(name) {
     return (

javascript/node/selenium-webdriver/bidi/protocolValue.js

@@ -98,6 +98,10 @@ class LocalValue {
     return new LocalValue(NonPrimitiveType.SET, value)
   }
 
+  static createChannelValue(value) {
+    return new LocalValue(NonPrimitiveType.CHANNEL, value)
+  }
+
   toJson() {
     let toReturn = {}
     toReturn[TYPE_CONSTANT] = this.type
@@ -195,10 +199,56 @@ class RegExpValue {
   }
 }
 
+class SerializationOptions {
+  constructor(
+    maxDomDepth = 0,
+    maxObjectDepth = null,
+    includeShadowTree = 'none'
+  ) {
+    this._maxDomDepth = maxDomDepth
+    this._maxObjectDepth = maxObjectDepth
+
+    if (['none', 'open', 'all'].includes(includeShadowTree)) {
+      throw Error(
+        `Valid types are 'none', 'open', and 'all'. Received: ${includeShadowTree}`
+      )
+    }
+    this._includeShadowTree = includeShadowTree
+  }
+}
+
+class ChannelValue {
+  constructor(channel, options = undefined, resultOwnership = undefined) {
+    this.channel = channel
+
+    if (options !== undefined) {
+      if (options instanceof SerializationOptions) {
+        this.options = options
+      } else {
+        throw Error(
+          `Pass in SerializationOptions object. Received: ${options} `
+        )
+      }
+    }
+
+    if (resultOwnership != undefined) {
+      if (['root', 'none'].includes(resultOwnership)) {
+        this.resultOwnership = resultOwnership
+      } else {
+        throw Error(
+          `Valid types are 'root' and 'none. Received: ${resultOwnership}`
+        )
+      }
+    }
+  }
+}
+
 module.exports = {
+  ChannelValue,
   LocalValue,
   RemoteValue,
   ReferenceValue,
   RemoteReferenceType,
   RegExpValue,
+  SerializationOptions,
 }

javascript/node/selenium-webdriver/bidi/realmInfo.js

@@ -96,4 +96,5 @@ class WindowRealmInfo extends RealmInfo {
 module.exports = {
   RealmInfo,
   RealmType,
+  WindowRealmInfo,
 }

javascript/node/selenium-webdriver/bidi/scriptManager.js

@@ -21,8 +21,10 @@ const {
   EvaluateResultException,
   ExceptionDetails,
 } = require('./evaluateResult')
-const { RealmInfo } = require('./realmInfo')
+const { Message } = require('./scriptTypes')
+const { RealmInfo, RealmType, WindowRealmInfo } = require('./realmInfo')
 const { RemoteValue } = require('./protocolValue')
+const { Source } = require('./scriptTypes')
 const { WebDriverError } = require('../lib/error')
 
 class ScriptManager {
@@ -348,6 +350,55 @@ class ScriptManager {
     let response = await this.bidi.send(command)
     return this.realmInfoMapper(response.result.realms)
   }
+
+  async onMessage(callback) {
+    await this.subscribeAndHandleEvent('script.message', callback)
+  }
+
+  async onRealmCreated(callback) {
+    await this.subscribeAndHandleEvent('script.realmCreated', callback)
+  }
+
+  async subscribeAndHandleEvent(eventType, callback) {
+    if (this._browsingContextIds != null) {
+      await this.bidi.subscribe(eventType, this._browsingContextIds)
+    } else {
+      await this.bidi.subscribe(eventType)
+    }
+    await this._on(callback)
+  }
+
+  async _on(callback) {
+    this.ws = await this.bidi.socket
+    this.ws.on('message', (event) => {
+      const { params } = JSON.parse(Buffer.from(event.toString()))
+      if (params) {
+        let response = null
+        if ('channel' in params) {
+          response = new Message(
+            params.channel,
+            new RemoteValue(params.data),
+            new Source(params.source)
+          )
+        } else if ('realm' in params) {
+          if (params.type === RealmType.WINDOW) {
+            response = new WindowRealmInfo(
+              params.realm,
+              params.origin,
+              params.type,
+              params.context,
+              params.sandbox
+            )
+          } else if (params.realm !== null && params.type !== null) {
+            response = new RealmInfo(params.realm, params.origin, params.type)
+          } else if (params.realm !== null) {
+            response = params.realm
+          }
+        }
+        callback(response)
+      }
+    })
+  }
 }
 
 async function getScriptManagerInstance(browsingContextId, driver) {

javascript/node/selenium-webdriver/bidi/scriptTypes.js

@@ -0,0 +1,58 @@
+// Licensed to the Software Freedom Conservancy (SFC) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The SFC licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+class Message {
+  constructor(channel, data, source) {
+    this._channel = channel
+    this._data = data
+    this._source = source
+  }
+
+  get channel() {
+    return this._channel
+  }
+
+  get data() {
+    return this._data
+  }
+
+  get source() {
+    return this._source
+  }
+}
+
+class Source {
+  constructor(source) {
+    this._browsingContextId = null
+    this._realmId = source.realm
+
+    // Browsing context is returned as an optional parameter
+    if ('context' in source) {
+      this._browsingContextId = source.context
+    }
+  }
+
+  get browsingContextId() {
+    return this._browsingContextId
+  }
+
+  get realmId() {
+    return this._realmId
+  }
+}
+
+module.exports = { Message, Source }

javascript/node/selenium-webdriver/test/bidi/bidi_test.js

@@ -32,6 +32,7 @@ const until = require('../../lib/until')
 // Imports for Script Module
 const ScriptManager = require('../../bidi/scriptManager')
 const {
+  ChannelValue,
   LocalValue,
   ReferenceValue,
   RemoteReferenceType,
@@ -2131,6 +2132,55 @@ suite(
 
         assert.equal(result_in_sandbox.result.type, 'undefined')
       })
+
+      it('can listen to channel message', async function () {
+        const manager = await ScriptManager(undefined, driver)
+
+        let message = null
+
+        await manager.onMessage((m) => {
+          message = m
+        })
+
+        let argumentValues = []
+        let value = new ArgumentValue(
+          LocalValue.createChannelValue(new ChannelValue('channel_name'))
+        )
+        argumentValues.push(value)
+
+        const result = await manager.callFunctionInBrowsingContext(
+          await driver.getWindowHandle(),
+          '(channel) => channel("foo")',
+          false,
+          argumentValues
+        )
+        assert.equal(result.resultType, EvaluateResultType.SUCCESS)
+        assert.notEqual(message, null)
+        assert.equal(message.channel, 'channel_name')
+        assert.equal(message.data.type, 'string')
+        assert.equal(message.data.value, 'foo')
+      })
+
+      it('can listen to realm created message', async function () {
+        const manager = await ScriptManager(undefined, driver)
+
+        let realmInfo = null
+
+        await manager.onRealmCreated((result) => {
+          realmInfo = result
+        })
+
+        const id = await driver.getWindowHandle()
+        const browsingContext = await BrowsingContext(driver, {
+          browsingContextId: id,
+        })
+
+        await browsingContext.navigate(Pages.blankPage, 'complete')
+
+        assert.notEqual(realmInfo, null)
+        assert.notEqual(realmInfo.realmId, null)
+        assert.equal(realmInfo.realmType, RealmType.WINDOW)
+      })
     })
 
     describe('Network Inspector', function () {