system-testing 1.0.23 → 1.0.25

package/README.md

@@ -0,0 +1,63 @@
+# System testing
+
+Rails inspired system testing for Expo apps.
+
+## Install
+
+```bash
+npm install --save-dev system-testing
+```
+
+## Usage
+
+```js
+import retry from "awaitery/src/retry.js"
+import SystemTest from "system-testing/src/system-test.js"
+import wait from "awaitery/src/wait.js"
+import waitFor from "awaitery/src/wait-for.js"
+
+import createUser from "@/src/testing/create-user.js"
+import initialize from "@/src/initialize"
+import Option from "@/src/models/option"
+
+describe("Sign in page", () => {
+  test("it navigates to the sign in page and signs in", async () => {
+    await initialize()
+
+    await SystemTest.run(async (systemTest) => {
+      await createUser(userAttributes)
+
+      await systemTest.visit("/")
+      await systemTest.findByTestID("frontpageScreen", {useBaseSelector: false})
+      await wait(250)
+
+      await retry(async () => {
+        await systemTest.click("[data-testid='signInButton']")
+        await systemTest.findByTestID("app/sign-in")
+      })
+
+      await systemTest.interact("[data-testid='signInEmailInput']", "sendKeys", "user@example.com")
+      await systemTest.interact("[data-testid='signInPasswordInput']", "sendKeys", "password")
+
+      const emailInputValue = await systemTest.interact("[data-testid='signInEmailInput']", "getAttribute", "value")
+      const passwordInputValue = await systemTest.interact("[data-testid='signInPasswordInput']", "getAttribute", "value")
+
+      expect(emailInputValue).toEqual("user@example.com")
+      expect(passwordInputValue).toEqual("password")
+
+      await systemTest.click("[data-testid='signInSubmitButton']")
+      await systemTest.expectNotificationMessage("You were signed in.")
+
+      await waitFor(async () => {
+        const optionUserID = await Option.findBy({key: "userID"})
+
+        if (!optionUserID) {
+          throw new Error("Option for user ID didn't exist")
+        }
+
+        expect(optionUserID.value()).toEqual("805")
+      })
+    })
+  })
+})
+```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "system-testing",
-  "version": "1.0.23",
+  "version": "1.0.25",
   "description": "System testing with Selenium and browsers.",
   "keywords": [
     "system",

package/src/system-test.js

@@ -151,14 +151,31 @@ export default class SystemTest {
    *
    * @param {import("selenium-webdriver").WebElement} element
    **/
-  async click(element) {
-    if (typeof element == "string") {
-      element = await this.find(element)
-    }
+  async click(elementOrIdentifier) {
+    let tries = 0
 
-    const actions = this.driver.actions({async: true})
+    while (true) {
+      tries++
 
-    await actions.move({origin: element}).click().perform()
+      try {
+        const element = await this._findElement(elementOrIdentifier)
+        const actions = this.driver.actions({async: true})
+
+        await actions.move({origin: element}).click().perform()
+        break
+      } catch (error) {
+        if (error.constructor.name === "ElementNotInteractableError") {
+          if (tries >= 3) {
+            throw new Error(`Element ${element.constructor.name} click failed after ${tries} tries - ${error.constructor.name}: ${error.message}`)
+          } else {
+            await wait(50)
+          }
+        } else {
+          // Re-throw with un-corrupted stack trace
+          throw new Error(`Element ${element.constructor.name} click failed - ${error.constructor.name}: ${error.message}`)
+        }
+      }
+    }
   }
 
   /**
@@ -198,6 +215,18 @@ export default class SystemTest {
    */
   async findByTestID(testID, args) { return await this.find(`[data-testid='${testID}']`, args) }
 
+  async _findElement(elementOrIdentifier) {
+    let element
+
+    if (typeof elementOrIdentifier == "string") {
+      element = await this.find(elementOrIdentifier)
+    } else {
+      element = elementOrIdentifier
+    }
+
+    return element
+  }
+
   /**
    * Finds a single element by CSS selector without waiting
    *
@@ -256,20 +285,17 @@ export default class SystemTest {
    * @returns {Promise<any>}
    */
   async interact(elementOrIdentifier, methodName, ...args) {
-    let element
     let tries = 0
 
     while (true) {
       tries++
 
-      if (typeof elementOrIdentifier == "string") {
-        element = await this.find(elementOrIdentifier)
-      } else {
-        element = elementOrIdentifier
-      }
+      const element = await this._findElement(elementOrIdentifier)
 
       if (!element[methodName]) {
-        // throw new Error(`${element.constructor.name} has no method named: ${methodName}`)
+        throw new Error(`${element.constructor.name} hasn't an attribute named: ${methodName}`)
+      } else if (typeof element[methodName] != "function") {
+        throw new Error(`${element.constructor.name}#${methodName} is not a function`)
       }
 
       try {
@@ -278,9 +304,17 @@ export default class SystemTest {
         if (error.constructor.name === "ElementNotInteractableError") {
           // Retry finding the element and interacting with it
           if (tries >= 3) {
-            throw new Error(`${element.constructor.name} ${methodName} failed after ${tries} tries - ${error.constructor.name}: ${error.message}`)
+            let elementDescription
+
+            if (typeof elementOrIdentifier == "string") {
+              elementDescription = `CSS selector ${elementOrIdentifier}`
+            } else {
+              elementDescription = `${element.constructor.name}`
+            }
+
+            throw new Error(`${elementDescription} ${methodName} failed after ${tries} tries - ${error.constructor.name}: ${error.message}`)
           } else {
-            await wait(100)
+            await wait(50)
           }
         } else {
           // Re-throw with un-corrupted stack trace
@@ -302,7 +336,7 @@ export default class SystemTest {
       await this.findNoWait(selector)
       found = true
     } catch (error) {
-      if (!error.message.startsWith("Element couldn't be found by CSS:")) {
+      if (!error.message.startsWith("Element couldn't be found after ")) {
         throw error
       }
     }