system-testing 1.0.31 → 1.0.33

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "system-testing",
-  "version": "1.0.31",
+  "version": "1.0.33",
   "description": "System testing with Selenium and browsers.",
   "keywords": [
     "system",
@@ -26,6 +26,7 @@
     "typecheck": "tsc --noEmit"
   },
   "dependencies": {
+    "@types/selenium-webdriver": "^4.35.4",
     "awaitery": "^1.0.2",
     "diggerize": "^1.0.9",
     "htmlfy": "^1.0.0",

package/src/system-test-communicator.js

@@ -1,6 +1,14 @@
 // @ts-check
 
 export default class SystemTestCommunicator {
+  /** @type {Record<string, {resolve: (data: any) => void, reject: (data: any) => void}>} */
+  _responses = {}
+
+  /** @type {Record<string, any>} */
+  _sendQueue = []
+
+  _sendQueueCount = 0
+
   /** @type {WebSocket | null} */
   ws = null
 
@@ -12,13 +20,6 @@ export default class SystemTestCommunicator {
   constructor({onCommand, parent}) {
     this.onCommand = onCommand
     this.parent = parent
-    this._sendQueueCount = 0
-
-    /** @type {Record<string, any>} */
-    this._sendQueue = []
-
-    /** @type {Record<string, {resolve: (data: any) => void, reject: (data: any) => void}>} */
-    this._responses = {}
   }
 
   flushSendQueue() {
@@ -81,20 +82,20 @@ export default class SystemTestCommunicator {
   }
 
   /**
-   * @param {object} data
+   * @param {Record<string, any>} data
    * @returns {void}
    */
   send(data) {
     this._sendQueue.push(data)
 
-    if (this.ws?.readyState == 1) {
+    if (this.ws.readyState == 1) {
       this.flushSendQueue()
     }
   }
 
   /**
    * Sends a command and returns a promise that resolves with the response.
-   * @param {object} data - The command data to send.
+   * @param {Record<string, any>} data - The command data to send.
    * @returns {Promise<void>} A promise that resolves with the response data.
    */
   sendCommand(data) {
@@ -103,13 +104,14 @@ export default class SystemTestCommunicator {
 
       this._sendQueueCount += 1
       this._responses[id] = {resolve, reject}
+
       this.send({type: "command", id, data})
     })
   }
 
   /**
    * @param {number} id
-   * @param {object} data
+   * @param {Record<string, any>} data
    * @returns {void}
    */
   respond(id, data) {

package/src/system-test-http-server.js

@@ -8,7 +8,11 @@ import url from "url"
 export default class SystemTestHttpServer {
   /** @returns {void} */
   close() {
-    this.httpServer?.close()
+    if (!this.httpServer) {
+      throw new Error("HTTP server is not initialized")
+    }
+
+    this.httpServer.close()
   }
 
   /**

package/src/system-test.js

@@ -1,7 +1,8 @@
 // @ts-check
 
-import {Builder, By, until} from "selenium-webdriver"
+import {Builder, By} from "selenium-webdriver"
 import chrome from "selenium-webdriver/chrome.js"
+import {digg} from "diggerize"
 import fs from "node:fs/promises"
 import logging from "selenium-webdriver/lib/logging.js"
 import moment from "moment"
@@ -15,17 +16,17 @@ import {WebSocketServer} from "ws"
 
 class ElementNotFoundError extends Error { }
 
-/** @type {{systemTest: SystemTest | null}} */
-const shared = {
-  systemTest: null
-}
-
 export default class SystemTest {
   static rootPath = "/blank?systemTest=true"
 
   /** @type {SystemTestCommunicator | undefined} */
   communicator = undefined
+
+  /** @type {import("selenium-webdriver").WebDriver | undefined} */
+  driver = undefined
+
   _started = false
+  _driverTimeouts = 5000
   _timeouts = 5000
 
   /**
@@ -36,11 +37,11 @@ export default class SystemTest {
    * @returns {SystemTest}
    */
   static current(args) {
-    if (!shared.systemTest) {
-      shared.systemTest = new SystemTest(args)
+    if (!globalThis.systemTest) {
+      globalThis.systemTest = new SystemTest(args)
     }
 
-    return shared.systemTest
+    return globalThis.systemTest
   }
 
   getCommunicator() {
@@ -87,7 +88,10 @@ export default class SystemTest {
 
     this._host = host
     this._port = port
+
+    /** @type {Record<number, object>} */
     this._responses = {}
+
     this._sendCount = 0
     this.startScoundrel()
     this.communicator = new SystemTestCommunicator({onCommand: this.onCommandReceived})
@@ -99,7 +103,11 @@ export default class SystemTest {
    */
   getBaseSelector() { return this._baseSelector }
 
+  /**
+   * @returns {import("selenium-webdriver").WebDriver}
+   */
   getDriver() {
+    if (!this) throw new Error("No this?")
     if (!this.driver) throw new Error("Driver hasn't been initialized yet")
 
     return this.driver
@@ -125,6 +133,8 @@ export default class SystemTest {
    * @returns {void}
    */
   startScoundrel() {
+    if (this.wss) throw new Error("Scoundrel server already started")
+
     this.wss = new WebSocketServer({port: 8090})
     this.serverWebSocket = new ServerWebSocket(this.wss)
     this.server = new Server(this.serverWebSocket)
@@ -142,18 +152,38 @@ export default class SystemTest {
    * Finds all elements by CSS selector
    * @param {string} selector
    * @param {object} args
+   * @param {number} [args.timeout]
    * @param {boolean} [args.visible]
    * @param {boolean} [args.useBaseSelector]
    * @returns {Promise<import("selenium-webdriver").WebElement[]>}
    */
   async all(selector, args = {}) {
-    const {visible = true, useBaseSelector = true, ...restArgs} = args
+    const {visible = true, timeout, useBaseSelector = true, ...restArgs} = args
     const restArgsKeys = Object.keys(restArgs)
+    let actualTimeout
+
+    if (timeout === undefined) {
+      actualTimeout = this._driverTimeouts
+    } else {
+      actualTimeout = timeout
+    }
 
     if (restArgsKeys.length > 0) throw new Error(`Unknown arguments: ${restArgsKeys.join(", ")}`)
 
     const actualSelector = useBaseSelector ? this.getSelector(selector) : selector
-    const elements = await this.getDriver().findElements(By.css(actualSelector))
+    const getElements = async () => await this.getDriver().findElements(By.css(actualSelector))
+    let elements = []
+
+    if (actualTimeout == 0) {
+      elements = await getElements()
+    } else {
+      await this.getDriver().wait(async () => {
+        elements = await getElements()
+
+        return elements.length > 0
+      }, actualTimeout)
+    }
+
     const activeElements = []
 
     for (const element of elements) {
@@ -215,13 +245,17 @@ export default class SystemTest {
    * @returns {Promise<import("selenium-webdriver").WebElement>}
    */
   async find(selector, args = {}) {
-    let elements
+    let elements = []
 
     try {
       elements = await this.all(selector, args)
     } catch (error) {
       // Re-throw to recover stack trace
       if (error instanceof Error) {
+        if (error.message.startsWith("Wait timed out after")) {
+          elements = []
+        }
+
         throw new Error(`${error.message} (selector: ${this.getSelector(selector)})`)
       } else {
         throw new Error(`${error} (selector: ${this.getSelector(selector)})`)
@@ -330,16 +364,16 @@ export default class SystemTest {
       tries++
 
       const element = await this._findElement(elementOrIdentifier)
-      const candidate = element[methodName]
 
-      if (!candidate) {
+      if (!element[methodName]) {
         throw new Error(`${element.constructor.name} hasn't an attribute named: ${methodName}`)
-      } else if (typeof candidate != "function") {
+      } else if (typeof element[methodName] != "function") {
         throw new Error(`${element.constructor.name}#${methodName} is not a function`)
       }
 
       try {
-        return await candidate(...args)
+        // Dont call with candidate, because that will bind the function wrong.
+        return await element[methodName](...args)
       } catch (error) {
         if (error instanceof Error) {
           if (error.constructor.name === "ElementNotInteractableError") {
@@ -399,31 +433,30 @@ export default class SystemTest {
    * @returns {Promise<void>}
    */
   async waitForNoSelector(selector, args) {
-    const timeStart = new Date().getTime()
-    const timeout = this.getTimeouts()
     const {useBaseSelector, ...restArgs} = args
 
     if (Object.keys(restArgs).length > 0) {
       throw new Error(`Unexpected args: ${Object.keys(restArgs).join(", ")}`)
     }
 
-    while (true) {
-      try {
-        const actualSelector = useBaseSelector ? this.getSelector(selector) : selector
-
-        await this.driver.wait(until.elementIsNotVisible(By.css(actualSelector)), 0)
+    const actualSelector = useBaseSelector ? this.getSelector(selector) : selector
 
-        const timeElapsed = new Date().getTime() - timeStart
+    await this.getDriver().wait(
+      async () => {
+        const elements = await this.getDriver().findElements(By.css(actualSelector))
 
-        if (timeElapsed > timeout) {
-          throw new Error(`Element still found after ${timeout}ms: ${selector}`)
-        }
-      } catch (error) {
-        if (error instanceof Error && error.message.startsWith("Element couldn't be found after ")) {
-          break
+        // Not found at all
+        if (elements.length === 0) {
+          return true
         }
-      }
-    }
+
+        // Found but not visible
+        const isDisplayed = await elements[0].isDisplayed()
+
+        return !isDisplayed
+      },
+      this.getTimeouts()
+    )
   }
 
   /**
@@ -526,10 +559,10 @@ export default class SystemTest {
     options.addArguments("--no-sandbox")
     options.addArguments("--window-size=1920,1080")
 
-    /** @type {import("selenium-webdriver").WebDriver} */
     this.driver = new Builder()
       .forBrowser("chrome")
       .setChromeOptions(options)
+      // @ts-expect-error
       .setCapability("goog:loggingPrefs", {browser: "ALL"})
       .build()
 
@@ -574,6 +607,7 @@ export default class SystemTest {
    * @returns {Promise<void>}
    */
   async driverSetTimeouts(newTimeout) {
+    this._driverTimeouts = newTimeout
     await this.getDriver().manage().setTimeouts({implicit: newTimeout})
   }
 
@@ -664,10 +698,10 @@ export default class SystemTest {
     this.getCommunicator().onOpen()
 
     // @ts-expect-error
-    this.ws.on("error", this.communicator.onError)
+    this.ws.on("error", digg(this, "communicator", "onError"))
 
     // @ts-expect-error
-    this.ws.on("message", this.communicator.onMessage)
+    this.ws.on("message", digg(this, "communicator", "onMessage"))
 
     if (this.waitForClientWebSocketPromiseResolve) {
       this.waitForClientWebSocketPromiseResolve()

package/tsconfig.json

@@ -8,6 +8,7 @@
     "module": "nodenext",
 
     "lib": ["dom", "ES2020"],
+    "sourceMap": true,
     "types": ["node"],
     "skipLibCheck": true
   }