create-appraisejs 0.3.1-alpha.0 → 0.3.1-alpha.1

package/templates/starter/automation/steps/actions/random_data.step.ts

@@ -1,144 +1,150 @@
 import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvironment, generateRandomData, RandomDataType } from '../../../packages/cucumber-runtime/src/index.js'
-/**
- * @name random data
- * @description Template steps that handles random data generation
- * @type ACTION
- */
-
-// This file is generated automatically. Add template steps to this group to generate content.
-
-/**
- * @name generate random first name and save in variable
- * @description Template step for generating a random first name and saving it inside a variable
- * @icon DATA
- */
-When(
-    'the user generates a random first name and stores it inside the variable {string}',
-    async function (this: CustomWorld, variableName: string) {
-        const data = generateRandomData(RandomDataType.FIRST_NAME);
-        try {
-            this.setVar(variableName, data);
-        } catch (error) {
-            throw new Error(`Failed to generate a random first name and store it inside the variable ${variableName}: ${error}`);
-        }
-    }
-);
-
-/**
- * @name generate random last name and save in variable
- * @description Template step for generating a random last name and saving it inside a variable
- * @icon DATA
- */
-When(
-    'the user generates a random last name and stores it inside the variable {string}',
-    async function (this: CustomWorld, variableName: string) {
-        const data = generateRandomData(RandomDataType.LAST_NAME);
-        try {
-            this.setVar(variableName, data);
-        } catch (error) {
-            throw new Error(`Failed to generate a random last name and store it inside the variable ${variableName}: ${error}`);
-        }
-    }
-);
-
-/**
- * @name generate random email and save in variable
- * @description Template step for generating a random email and saving it inside a variable
- * @icon DATA
- */
-When(
-    'the user generates a random email and stores it inside the variable {string}',
-    async function (this: CustomWorld, variableName: string) {
-        const data = generateRandomData(RandomDataType.EMAIL);
-        try {
-            this.setVar(variableName, data);
-        } catch (error) {
-            throw new Error(`Failed to generate a random email and store it inside the variable ${variableName}: ${error}`);
-        }
-    }
-);
-
-/**
- * @name generate random password and save in variable
- * @description Template step for generating a random password and saving it inside a variable
- * @icon DATA
- */
-When(
-    'the user generates a random password and stores it inside the variable {string}',
-    async function (this: CustomWorld, variableName: string) {
-        const data = generateRandomData(RandomDataType.PASSWORD);
-        try {
-            this.setVar(variableName, data);
-        } catch (error) {
-            throw new Error(`Failed to generate a random password and store it inside the variable ${variableName}: ${error}`);
-        }
-    }
-);
-
-/**
- * @name generate random phone and save in variable
- * @description Template step for generating a random phone and saving it inside a variable
- * @icon DATA
- */
-When(
-    'the user generates a random phone and stores it inside the variable {string}',
-    async function (this: CustomWorld, variableName: string) {
-        const data = generateRandomData(RandomDataType.PHONE);
-        try {
-            this.setVar(variableName, data);
-        } catch (error) {
-            throw new Error(`Failed to generate a random phone and store it inside the variable ${variableName}: ${error}`);
-        }
-    }
-);
-
-/**
- * @name generate random address and save in variable
- * @description Template step for generating a random address and saving it inside a variable
- * @icon DATA
- */
-When(
-    'the user generates a random address and stores it inside the variable {string}',
-    async function (this: CustomWorld, variableName: string) {
-        const data = generateRandomData(RandomDataType.ADDRESS);
-        try {
-            this.setVar(variableName, data);
-        } catch (error) {
-            throw new Error(`Failed to generate a random address and store it inside the variable ${variableName}: ${error}`);
-        }
-    }
-);
-
-/**
- * @name generate random unique text and save in variable
- * @description Template step for generating a random unique text and saving it inside a variable
- * @icon DATA   
- */
-When(
-    'the user generates a random unique text and stores it inside the variable {string}',
-    async function (this: CustomWorld, variableName: string) {
-        const data = generateRandomData(RandomDataType.UNIQUE_TEXT);
-        try {
-            this.setVar(variableName, data);
-        } catch (error) {
-            throw new Error(`Failed to generate a random unique text and store it inside the variable ${variableName}: ${error}`);
-        }
-    }
-);
-
-/**
- * @name generate random full name and save in variable
- * @description Template step for generating a random full name and saving it inside a variable
- * @icon DATA
- */
-When(
-    'the user generates a random full name and stores it inside the variable {string}',
-    async function (this: CustomWorld, variableName: string) {
-        const data = generateRandomData(RandomDataType.FULL_NAME);
-        try {
-            this.setVar(variableName, data);
-        } catch (error) {
-            throw new Error(`Failed to generate a random full name and store it inside the variable ${variableName}: ${error}`);
-        }
-    }
-);
+/**
+ * @name random data
+ * @description Template steps that handles random data generation
+ * @type ACTION
+ */
+
+/**
+ * @name generate random address and save in variable
+ * @description Template step for generating a random address and saving it inside a variable
+ * @icon DATA
+ */
+When(
+  'the user generates a random address and stores it inside the variable {string}',
+  async function (this: CustomWorld, variableName: string) {
+    const data = generateRandomData(RandomDataType.ADDRESS)
+    try {
+      this.setVar(variableName, data)
+    } catch (error) {
+      throw new Error(`Failed to generate a random address and store it inside the variable ${variableName}: ${error}`)
+    }
+  },
+)
+
+/**
+ * @name generate random email and save in variable
+ * @description Template step for generating a random email and saving it inside a variable
+ * @icon DATA
+ */
+When(
+  'the user generates a random email and stores it inside the variable {string}',
+  async function (this: CustomWorld, variableName: string) {
+    const data = generateRandomData(RandomDataType.EMAIL)
+    try {
+      this.setVar(variableName, data)
+    } catch (error) {
+      throw new Error(`Failed to generate a random email and store it inside the variable ${variableName}: ${error}`)
+    }
+  },
+)
+
+/**
+ * @name generate random first name and save in variable
+ * @description Template step for generating a random first name and saving it inside a variable
+ * @icon DATA
+ */
+When(
+  'the user generates a random first name and stores it inside the variable {string}',
+  async function (this: CustomWorld, variableName: string) {
+    const data = generateRandomData(RandomDataType.FIRST_NAME)
+    try {
+      this.setVar(variableName, data)
+    } catch (error) {
+      throw new Error(
+        `Failed to generate a random first name and store it inside the variable ${variableName}: ${error}`,
+      )
+    }
+  },
+)
+
+/**
+ * @name generate random full name and save in variable
+ * @description Template step for generating a random full name and saving it inside a variable
+ * @icon DATA
+ */
+When(
+  'the user generates a random full name and stores it inside the variable {string}',
+  async function (this: CustomWorld, variableName: string) {
+    const data = generateRandomData(RandomDataType.FULL_NAME)
+    try {
+      this.setVar(variableName, data)
+    } catch (error) {
+      throw new Error(
+        `Failed to generate a random full name and store it inside the variable ${variableName}: ${error}`,
+      )
+    }
+  },
+)
+
+/**
+ * @name generate random last name and save in variable
+ * @description Template step for generating a random last name and saving it inside a variable
+ * @icon DATA
+ */
+When(
+  'the user generates a random last name and stores it inside the variable {string}',
+  async function (this: CustomWorld, variableName: string) {
+    const data = generateRandomData(RandomDataType.LAST_NAME)
+    try {
+      this.setVar(variableName, data)
+    } catch (error) {
+      throw new Error(
+        `Failed to generate a random last name and store it inside the variable ${variableName}: ${error}`,
+      )
+    }
+  },
+)
+
+/**
+ * @name generate random password and save in variable
+ * @description Template step for generating a random password and saving it inside a variable
+ * @icon DATA
+ */
+When(
+  'the user generates a random password and stores it inside the variable {string}',
+  async function (this: CustomWorld, variableName: string) {
+    const data = generateRandomData(RandomDataType.PASSWORD)
+    try {
+      this.setVar(variableName, data)
+    } catch (error) {
+      throw new Error(`Failed to generate a random password and store it inside the variable ${variableName}: ${error}`)
+    }
+  },
+)
+
+/**
+ * @name generate random phone and save in variable
+ * @description Template step for generating a random phone and saving it inside a variable
+ * @icon DATA
+ */
+When(
+  'the user generates a random phone and stores it inside the variable {string}',
+  async function (this: CustomWorld, variableName: string) {
+    const data = generateRandomData(RandomDataType.PHONE)
+    try {
+      this.setVar(variableName, data)
+    } catch (error) {
+      throw new Error(`Failed to generate a random phone and store it inside the variable ${variableName}: ${error}`)
+    }
+  },
+)
+
+/**
+ * @name generate random unique text and save in variable
+ * @description Template step for generating a random unique text and saving it inside a variable
+ * @icon DATA
+ */
+When(
+  'the user generates a random unique text and stores it inside the variable {string}',
+  async function (this: CustomWorld, variableName: string) {
+    const data = generateRandomData(RandomDataType.UNIQUE_TEXT)
+    try {
+      this.setVar(variableName, data)
+    } catch (error) {
+      throw new Error(
+        `Failed to generate a random unique text and store it inside the variable ${variableName}: ${error}`,
+      )
+    }
+  },
+)

package/templates/starter/automation/steps/actions/store.step.ts

@@ -5,4 +5,72 @@ import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvir
  * @type ACTION
  */
 
-// This file is generated automatically. Add template steps to this group to generate content.
+/**
+ * @name store element text
+ * @description Store an element's text content inside a runtime variable
+ * @icon STORE
+ */
+When(
+  'the user stores the {string} element text inside the variable {string}',
+  async function (this: CustomWorld, elementName: SelectorName, variableName: string) {
+    const selector = await resolveLocator(this.page, elementName)
+    if (!selector) {
+      throw new Error(`Selector ${elementName} not found`)
+    }
+
+    try {
+      const value = await this.page.locator(selector).textContent()
+      this.setVar(variableName, value ?? '')
+    } catch (error) {
+      throw new Error(`Failed to store the ${elementName} element text inside the variable ${variableName}: ${error}`)
+    }
+  },
+)
+
+/**
+ * @name store text input text
+ * @description Store a text input value inside a runtime variable
+ * @icon STORE
+ */
+When(
+  'the user stores the {string} text input value inside the variable {string}',
+  async function (this: CustomWorld, elementName: SelectorName, variableName: string) {
+    const selector = await resolveLocator(this.page, elementName)
+    if (!selector) {
+      throw new Error(`Selector ${elementName} not found`)
+    }
+
+    try {
+      const value = await this.page.locator(selector).inputValue()
+      this.setVar(variableName, value)
+    } catch (error) {
+      throw new Error(
+        `Failed to store the ${elementName} text input value inside the variable ${variableName}: ${error}`,
+      )
+    }
+  },
+)
+
+/**
+ * @name store textarea text
+ * @description Store a textarea value inside a runtime variable
+ * @icon STORE
+ */
+When(
+  'the user stores the {string} textarea input value inside the variable {string}',
+  async function (this: CustomWorld, elementName: SelectorName, variableName: string) {
+    const selector = await resolveLocator(this.page, elementName)
+    if (!selector) {
+      throw new Error(`Selector ${elementName} not found`)
+    }
+
+    try {
+      const value = await this.page.locator(selector).inputValue()
+      this.setVar(variableName, value)
+    } catch (error) {
+      throw new Error(
+        `Failed to store the ${elementName} textarea input value inside the variable ${variableName}: ${error}`,
+      )
+    }
+  },
+)

package/templates/starter/automation/steps/actions/wait.step.ts

@@ -5,4 +5,87 @@ import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvir
  * @type ACTION
  */
 
-// This file is generated automatically. Add template steps to this group to generate content.
+/**
+ * @name wait for element
+ * @description Wait for an element to become visible
+ * @icon WAIT
+ */
+When(
+  'the user waits for the element {string} to become visible',
+  async function (this: CustomWorld, elementName: SelectorName) {
+    const selector = await resolveLocator(this.page, elementName, {
+      validate: { requireVisible: false },
+    })
+    if (!selector) {
+      throw new Error(`Selector ${elementName} not found`)
+    }
+
+    try {
+      await this.page.locator(selector).waitFor({ state: 'visible' })
+    } catch (error) {
+      throw new Error(`Failed to wait for the element ${elementName} to become visible: ${error}`)
+    }
+  },
+)
+
+/**
+ * @name wait for element to disappear
+ * @description Wait for an element to become hidden or detached
+ * @icon WAIT
+ */
+When(
+  'the user waits for the {string} element to disappear',
+  async function (this: CustomWorld, elementName: SelectorName) {
+    const selector = await resolveLocator(this.page, elementName, {
+      validate: { requireVisible: false },
+    })
+    if (!selector) {
+      throw new Error(`Selector ${elementName} not found`)
+    }
+
+    try {
+      await this.page.locator(selector).waitFor({ state: 'hidden' })
+    } catch (error) {
+      throw new Error(`Failed to wait for the ${elementName} element to disappear: ${error}`)
+    }
+  },
+)
+
+/**
+ * @name wait for page load
+ * @description Wait for the current page to finish loading
+ * @icon WAIT
+ */
+When('the user waits for the current page to be loaded', async function (this: CustomWorld) {
+  try {
+    await this.page.waitForLoadState('domcontentloaded')
+  } catch (error) {
+    throw new Error(`Failed to wait for the current page to be loaded: ${error}`)
+  }
+})
+
+/**
+ * @name wait for specific amount of seconds
+ * @description Wait for a specific number of seconds
+ * @icon WAIT
+ */
+When('the user waits for {int} seconds', async function (this: CustomWorld, seconds: number) {
+  try {
+    await this.page.waitForTimeout(seconds * 1000)
+  } catch (error) {
+    throw new Error(`Failed to wait for ${seconds} seconds: ${error}`)
+  }
+})
+
+/**
+ * @name wait for url route
+ * @description Wait for the current URL path to match a route
+ * @icon WAIT
+ */
+When('the user waits for the route {string} to be loaded', async function (this: CustomWorld, route: string) {
+  try {
+    await this.page.waitForURL(url => url.pathname === route || url.pathname.endsWith(route))
+  } catch (error) {
+    throw new Error(`Failed to wait for the route ${route} to be loaded: ${error}`)
+  }
+})

package/templates/starter/automation/steps/validations/active_state_assertion.step.ts

@@ -1,31 +1,29 @@
 import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvironment, generateRandomData, RandomDataType } from '../../../packages/cucumber-runtime/src/index.js'
-/**
- * @name active state assertion
- * @description Template steps for handling the validation of the active state of an element
- * @type VALIDATION
- */
-
-// This file is generated automatically. Add template steps to this group to generate content.
-
-/**
- * @name assert element active
- * @description Template step for validating whether an element is active or not
- * @icon VALIDATION
- */
-Then(
-  'the element {string} should have active status {boolean} ',
-  async function (this: CustomWorld, elementName: SelectorName, isActive: boolean) {
-    try {
-      const selector = await resolveLocator(this.page, elementName)
-      if (!selector) throw new Error(`Selector ${elementName} not found`)
-      const elementActiveStatus = await this.page.locator(selector).isEnabled({ timeout: 10000 })
-      if (isActive) {
-        void expect(elementActiveStatus, `Expected ${elementName} to be active`).to.be.true
-      } else {
-        void expect(elementActiveStatus, `Expected ${elementName} NOT to be active`).to.be.false
-      }
-    } catch (error) {
-      throw new Error(`Failed to validate the active status of the element ${elementName}: ${error}`)
-    }
-  },
-)
+/**
+ * @name active state assertion
+ * @description Template steps for handling the validation of the active state of an element
+ * @type VALIDATION
+ */
+
+/**
+ * @name assert element active
+ * @description Template step for validating whether an element is active or not
+ * @icon VALIDATION
+ */
+Then(
+  'the element {string} should have active status {boolean} ',
+  async function (this: CustomWorld, elementName: SelectorName, isActive: boolean) {
+    try {
+      const selector = await resolveLocator(this.page, elementName)
+      if (!selector) throw new Error(`Selector ${elementName} not found`)
+      const elementActiveStatus = await this.page.locator(selector).isEnabled({ timeout: 10000 })
+      if (isActive) {
+        void expect(elementActiveStatus, `Expected ${elementName} to be active`).to.be.true
+      } else {
+        void expect(elementActiveStatus, `Expected ${elementName} NOT to be active`).to.be.false
+      }
+    } catch (error) {
+      throw new Error(`Failed to validate the active status of the element ${elementName}: ${error}`)
+    }
+  },
+)

package/templates/starter/automation/steps/validations/navigation_assertion.step.ts

@@ -1,23 +1,21 @@
 import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvironment, generateRandomData, RandomDataType } from '../../../packages/cucumber-runtime/src/index.js'
-/**
- * @name navigation assertion
- * @description Template steps that handles navigation validations
- * @type VALIDATION
- */
-
-// This file is generated automatically. Add template steps to this group to generate content.
-
-/**
- * @name assert url route equals
- * @description Template step for validating whether a url route equals the provided value or not
- * @icon VALIDATION
- */
-Then('the url route should be equal to {string}', async function (this: CustomWorld, route: string) {
-  try {
-    await this.page.waitForLoadState('networkidle')
-    const currentRoute = new URL(this.page.url()).pathname
-    expect(currentRoute, `Expected the current route to be "${route}"`).to.equal(route.toLowerCase())
-  } catch (error) {
-    throw new Error(`Failed to validate the equality of the current route to the route "${route}": ${error}`)
-  }
-})
+/**
+ * @name navigation assertion
+ * @description Template steps that handles navigation validations
+ * @type VALIDATION
+ */
+
+/**
+ * @name assert url route equals
+ * @description Template step for validating whether a url route equals the provided value or not
+ * @icon VALIDATION
+ */
+Then('the url route should be equal to {string}', async function (this: CustomWorld, route: string) {
+  try {
+    await this.page.waitForLoadState('networkidle')
+    const currentRoute = new URL(this.page.url()).pathname
+    expect(currentRoute, `Expected the current route to be "${route}"`).to.equal(route.toLowerCase())
+  } catch (error) {
+    throw new Error(`Failed to validate the equality of the current route to the route "${route}": ${error}`)
+  }
+})