topological-nodered-wdio 0.2.6

package/src/new-session.js

@@ -0,0 +1,102 @@
+const common = require('./wdio-common')
+
+module.exports = function(RED) {
+  function newSession(config) {
+    RED.nodes.createNode(this, config)
+    const node = this
+
+    common.clearStatus(node)
+
+    node.on('input', async (msg) => {
+      try {
+        const webdriverConfig = Object.assign(
+          { logLevel: config.logLevel },
+          parseUri(config.webdriverUri || msg.webdriverUri, node),
+          getCapabilities(
+            config.webdriverProvider,
+            config.webdriverBrowser || msg.webdriverBrowser,
+            config.browserlessToken
+          )
+        )
+        node.log = `Open new browser.`
+        let b = await common.newSession(webdriverConfig, node, node.context())
+        await common.log(node)
+        common.connectedStatus(node)
+        msg.payload = b.sessionId
+        node.send(msg)
+      } catch (e) {
+        common.handleError(e, node, msg)
+      }
+    })
+
+    node.on('close', async (done) => {
+      try {
+        if (config.killSession) {
+          let b = await common.deleteSession(node.context())
+          let sessionId = ''
+          if (b && b.sessionId) sessionId = b.sessionId
+          common.disconnectedStatus(node)
+          node.log('Disconnected webdriver session ' + sessionId)
+        }
+      } catch (e) {
+        common.handleError(e, node, msg)
+      }
+      done()
+    })
+  }
+  RED.nodes.registerType('new-session', newSession)
+}
+
+const parseUri = (uri, node) => {
+  let uriComponents
+  try {
+    if (uri[uri.length - 1] !== '/') uri += '/'
+    let parsed = uri.match(/(\w+):\/\/(.+):(\d+)(\/.*)/)
+    uriComponents = {
+      protocol: parsed[1],
+      hostname: parsed[2],
+      port: parseInt(parsed[3]),
+      path: parsed[4]
+    }
+  } catch (e) {
+    common.handleError(
+      new Error(
+        'Invalid URI, expected format "<protocol>://<host>:<port>/<path>'
+      ),
+      node
+    )
+  }
+
+  return uriComponents
+}
+
+const getCapabilities = (vendor, browser) => {
+  let capabilities
+
+  if (vendor === 'browserless.io') {
+    capabilities = {
+      browserName: browser,
+      'goog:chromeOptions': {
+        args: ['--headless', '--no-sandbox']
+      }
+    }
+  } else if (vendor === 'local' && browser === 'chromium') {
+    capabilities = {
+      browserName: 'chrome',
+      'goog:chromeOptions': {
+        args: ['--headless', '--no-sandbox'],
+        w3c: false
+      }
+    }
+  } else if (vendor === 'local') {
+    capabilities = {
+      browserName: browser,
+      //platformName: 'Linux',
+      'goog:chromeOptions': {
+        w3c: false
+      }
+    }
+  }
+
+  return { capabilities }
+}

package/src/wdio-common.js

@@ -0,0 +1,151 @@
+const wdio = require('webdriverio')
+let newSessionNode
+
+module.exports.getBrowser = (context) => {
+  let browser = context.flow.get('wdio_browser')
+  if (!browser || !browser.sessionId)
+    throw new Error('No session defined - call newSession first')
+
+  return browser
+}
+
+/*
+config = {
+    logLevel: 'error',
+    protocol: 'https',
+    hostname: '<key>@chrome.browserless.io',
+    port: 443,
+    path: '/webdriver',
+    capabilities: {
+        browserName: 'chrome',
+        chromeOptions: {
+            args: ['--headless', '--no-sandbox']
+        }
+    }
+}
+*/
+module.exports.newSession = async (config, node, context) => {
+  let browser
+  try {
+    browser = await wdio.remote(config)
+    context.flow.set('wdio_browser', browser)
+    newSessionNode = node
+  } catch (e) {
+    throw e
+  }
+  return browser
+}
+
+module.exports.deleteSession = async (context) => {
+  let b
+  let browser = context.flow.get('wdio_browser')
+  try {
+    b = { sessionId: browser.sessionId }
+    await browser.closeWindow()
+    await browser.deleteSession()
+    context.flow.set('wdio_browser', null)
+    if (newSessionNode) module.exports.disconnected(newSessionNode)
+  } catch (e) {}
+  return b
+}
+
+module.exports.getElementId = async (browser, using, value) => {
+  let elementId
+  try {
+    const element = await browser.findElement(using, value)
+    if (element && Object.keys(element)) {
+      elementId = element[Object.keys(element)[0]]
+    } else {
+      let e
+      if (element && element.message) {
+        e = element.message
+      } else {
+        e = 'Element not found'
+      }
+      throw new Error(e)
+    }
+  } catch (e) {
+    throw e
+  }
+  return elementId
+}
+
+module.exports.getElement = async (browser, using, value) => {
+  let selector = ''
+  let element
+  switch (using) {
+    case 'id':
+      selector = '#' + value
+      break
+    case 'name':
+      selector = value
+      break
+    case 'className':
+      selector = '.' + value
+      break
+    case 'selector':
+      selector = value
+      break
+    default:
+      selector = value
+      break
+  }
+
+  try {
+    element = await browser.$(selector)
+  } catch (e) {
+    throw e
+  }
+
+  return element
+}
+
+module.exports.handleError = (e, node, msg) => {
+  console.log(e)
+  module.exports.errorStatus(node)
+  node.error(e, msg)
+}
+
+module.exports.clearStatus = (node) => {
+  node.status({})
+}
+
+module.exports.connectedStatus = (node) => {
+  node.status({
+    fill: 'green',
+    shape: 'dot',
+    text: 'connected'
+  })
+}
+
+module.exports.disconnectedStatus = (node) => {
+  node.status({
+    fill: 'green',
+    shape: 'ring',
+    text: 'disconnected'
+  })
+}
+
+module.exports.successStatus = (node) => {
+  node.status({
+    fill: 'green',
+    shape: 'ring',
+    text: 'done'
+  })
+}
+
+module.exports.errorStatus = (node) => {
+  node.status({
+    fill: 'red',
+    shape: 'ring',
+    text: 'error'
+  })
+}
+
+module.exports.log = async (node) => {
+  let context = node.context()
+  let stepCount = await (context.global.get('stepCount') || 0) + 1
+  let document = await context.global.get('document') || ''
+  await context.global.set('document', `${document}\n${stepCount}. Node: ${node.name} - \t${node.log}`)
+  await context.global.set('stepCount', stepCount)
+}

package/src/window-action.html

@@ -0,0 +1,91 @@
+<script type="text/javascript">
+  function setWindowAction() {
+    let action = $('#node-input-action').val()
+    $('#actionValue').hide()
+    $('#actionIndex').hide()
+    if (action === 'byName' || action === 'open') {
+      $('#actionValue').show()
+    }
+    if (action == 'byIndex') {
+      $('#actionIndex').show()
+    }
+  }
+
+  RED.nodes.registerType('window-action', {
+    category: 'Webdriver IO',
+    color: '#a6bbcf',
+    defaults: {
+      name: { value: '' },
+      action: { value: 'byName' },
+      value: { value: '' },
+      index: { value: '' }
+    },
+    inputs: 1,
+    outputs: 1,
+    icon: 'white-globe.png',
+    label: function() {
+      return this.name || 'window action'
+    },
+    oneditprepare: function() {
+      setWindowAction()
+    }
+  })
+</script>
+
+<script type="text/x-red" data-template-name="window-action">
+  <div class="form-row">
+      <label for="node-input-action"><i class="fa fa-tasks"></i> Action</label>
+      <select type="text" id="node-input-action" style="width:70%;" onchange="setWindowAction()">
+          <option value="byName">Switch to Window by Name</option>
+          <option value="byIndex">Switch to Window by Index</option>
+          <option value="getHandle">Get Window handle</option>
+          <option value="close">Close Window</option>
+          <option value="open">Open Window</option>
+      </select>
+  </div>
+  <div class="form-row" id="actionValue">
+      <label for="node-input-value"><i class="fa fa-tasks"></i> Window Name</label>
+      <input id="node-input-value" type="text" placeholder="URL or Title of window">
+  </div>
+  <div class="form-row" id="actionIndex">
+      <label for="node-input-index"><i class="fa fa-tasks"></i> Index</label>
+      <input id="node-input-index" type="text" placeholder="starts 0">
+  </div>
+  <div class="form-row">
+      <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+      <input id="node-input-name" type="text">
+  </div>
+</script>
+
+<script type="text/x-red" data-help-name="window-action">
+  <h3>Selected action of the node performs on browser windows.</h3>
+
+  <h3>Inputs</h3>
+        <dl class="message-properties">
+          <dt><code>msg.value</code>: <span class="property-type">string</span></dt>
+          <dd>URL or Title the window to target</dd>
+          <dt><code>msg.index</code><span class="property-type">string</span></dt>
+          <dd>zero-based index to target the desired window<br></dd>
+        </dl>
+  <h3>Details</h3>
+      <dl class="message-properties">
+          <dt>Action: <span class="property-type">Select</span></dt>
+          <dd>
+            <ul>
+                <li><b>Switch to Window by Name</b></li>
+                <ul>
+                    <li>Use URL or Title to switch to the browser tab/window.</li>
+                </ul>
+                <li><b>Switch to Window by Index</b></li>
+                <ul>
+                    <li>Use a zero-based index to target the browser tab/window</li>
+                </ul>
+                <li><b>Get window Handle</b></li>
+                <li><b>Close Window</b></li>
+                <li><b>Open Window</b></li>
+            </ul>
+          </dd>
+      </dl>
+
+</script>
+

package/src/window-action.js

@@ -0,0 +1,42 @@
+const common = require('./wdio-common')
+
+module.exports = function(RED) {
+  function windowAction(config) {
+    RED.nodes.createNode(this, config)
+    const node = this
+    common.clearStatus(node)
+
+    node.on('input', async (msg) => {
+      try {
+        let browser = await common.getBrowser(node.context())
+
+        let value = config.value || msg.value
+        let index = config.index || msg.index
+
+        if (config.action === 'byName') {
+          node.log = `Switch to the browser window with window title: "${value}".`
+          await browser.switchWindow(value)
+        } else if (config.action === 'byIndex') {
+          node.log = `Switch to the browser window with window index: "${index}".`
+          let handles = await browser.getWindowHandles()
+          await browser.switchWindow(handles[index])
+        } else if (config.action === 'getHandle') {
+          node.log = `Get all the browser windows.`
+          msg.payload = await browser.getWindowHandles()
+        } else if (config.action === 'close') {
+          node.log = `Close the active browser window.`
+          await browser.closeWindow()
+        } else if (config.action === 'open') {
+          node.log = `Open a new window with url: "${value}".`
+          await browser.createWindow(value)
+        }
+        await common.log(node)
+        common.successStatus(node)
+        node.send(msg)
+      } catch (e) {
+        common.handleError(e, node, msg)
+      }
+    })
+  }
+  RED.nodes.registerType('window-action', windowAction)
+}