create-appraisejs 0.3.0 → 0.3.1-alpha.1

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

@@ -5,8 +5,6 @@ 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 hover
  * @description Template step for hovering over an element
@@ -16,13 +14,13 @@ When(
   'the user hovers the cursor over the {string} element',
   async function (this: CustomWorld, elementName: SelectorName) {
     try {
-      const selector = await resolveLocator(this.page, elementName);
+      const selector = await resolveLocator(this.page, elementName)
       if (!selector) {
-        throw new Error(`Selector ${elementName} not found`);
+        throw new Error(`Selector ${elementName} not found`)
       }
-      await this.page.locator(selector).hover();
+      await this.page.locator(selector).hover()
     } catch (error) {
-      throw new Error(`Failed to hover over the ${elementName} element: ${error}`);
+      throw new Error(`Failed to hover over the ${elementName} element: ${error}`)
     }
-  }
-);
+  },
+)

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

@@ -5,142 +5,119 @@ 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 fill
- * @description Template step for filling up an input field with a provided value
+ * @name check
+ * @description Template step for checking a checkbox
  * @icon INPUT
  */
-When(
-    'the user fills in the {string} input field with value {string}',
-    async function (this: CustomWorld, elementName: SelectorName, value: string) {
-        const selector = await resolveLocator(this.page, elementName);
-        if (!selector) {
-            throw new Error(`Selector ${elementName} not found`);
-        }
-        try {
-            await this.page.locator(selector).fill(value);
-        } catch (error) {
-            throw new Error(
-                `Failed to fill in the ${elementName} input field with value ${value}: ${error}`
-            );
-        }
-    }
-);
+When('the user checks the {string} checkbox', async function (this: CustomWorld, elementName: SelectorName) {
+  const selector = await resolveLocator(this.page, elementName)
+  if (!selector) {
+    throw new Error(`Selector ${elementName} not found`)
+  }
+  try {
+    await this.page.locator(selector).check()
+  } catch (error) {
+    throw new Error(`Failed to check the ${elementName} checkbox: ${error}`)
+  }
+})
 
 /**
  * @name clear
  * @description Template step for clearing an input field
  * @icon INPUT
  */
-When(
-    'the user clears the {string} field',
-    async function (this: CustomWorld, elementName: SelectorName) {
-        const selector = await resolveLocator(this.page, elementName);
-        if (!selector) {
-            throw new Error(`Selector ${elementName} not found`);
-        }
-        try {
-            await this.page.locator(selector).clear();
-        } catch (error) {
-            throw new Error(`Failed to clear the ${elementName} field: ${error}`);
-        }
-    }
-);
+When('the user clears the {string} field', async function (this: CustomWorld, elementName: SelectorName) {
+  const selector = await resolveLocator(this.page, elementName)
+  if (!selector) {
+    throw new Error(`Selector ${elementName} not found`)
+  }
+  try {
+    await this.page.locator(selector).clear()
+  } catch (error) {
+    throw new Error(`Failed to clear the ${elementName} field: ${error}`)
+  }
+})
 
 /**
- * @name select dropdown option
- * @description Template step for selecting a particular option inside a dropdown element
+ * @name fill
+ * @description Template step for filling up an input field with a provided value
  * @icon INPUT
  */
 When(
-    'the user selects the {string} option of the {string} dropdown',
-    async function (
-        this: CustomWorld,
-        optionName: string,
-        elementName: SelectorName
-    ) {
-        const selector = await resolveLocator(this.page, elementName);
-        if (!selector) {
-            throw new Error(`Selector ${elementName} not found`);
-        }
-        try {
-            await this.page.locator(selector).selectOption(optionName);
-        } catch (error) {
-            throw new Error(
-                `Failed to select the ${optionName} option of the ${elementName} dropdown: ${error}`
-            );
-        }
+  'the user fills in the {string} input field with value {string}',
+  async function (this: CustomWorld, elementName: SelectorName, value: string) {
+    const selector = await resolveLocator(this.page, elementName)
+    if (!selector) {
+      throw new Error(`Selector ${elementName} not found`)
+    }
+    try {
+      await this.page.locator(selector).fill(value)
+    } catch (error) {
+      throw new Error(`Failed to fill in the ${elementName} input field with value ${value}: ${error}`)
     }
-);
+  },
+)
 
 /**
- * @name check
- * @description Template step for checking a checkbox
+ * @name fill input with stored value
+ * @description Template step for filling an input field with data from a stored variable
  * @icon INPUT
  */
 When(
-    'the user checks the {string} checkbox',
-    async function (this: CustomWorld, elementName: SelectorName) {
-        const selector = await resolveLocator(this.page, elementName);
-        if (!selector) {
-            throw new Error(`Selector ${elementName} not found`);
-        }
-        try {
-            await this.page.locator(selector).check();
-        } catch (error) {
-            throw new Error(`Failed to check the ${elementName} checkbox: ${error}`);
-        }
+  'the user fills in the {string} input with data from the stored variable {string}',
+  async function (this: CustomWorld, fieldName: SelectorName, variableName: string) {
+    const value = this.getVar<string>(variableName)
+    if (!value) {
+      throw new Error(`Variable ${variableName} not found`)
+    }
+    const selector = await resolveLocator(this.page, fieldName)
+    if (!selector) {
+      throw new Error(`Selector ${fieldName} not found`)
+    }
+    try {
+      await this.page.locator(selector).fill(value)
+    } catch (error) {
+      throw new Error(
+        `Failed to fill in the ${fieldName} input field with data from the stored variable ${variableName}: ${error}`,
+      )
     }
-);
+  },
+)
 
 /**
- * @name uncheck
- * @description Template step for unchecking a checkbox
+ * @name select dropdown option
+ * @description Template step for selecting a particular option inside a dropdown element
  * @icon INPUT
  */
 When(
-    'the user unchecks the {string} checkbox',
-    async function (this: CustomWorld, elementName: SelectorName) {
-        const selector = await resolveLocator(this.page, elementName);
-        if (!selector) {
-            throw new Error(`Selector ${elementName} not found`);
-        }
-        try {
-            await this.page.locator(selector).uncheck();
-        } catch (error) {
-            throw new Error(
-                `Failed to uncheck the ${elementName} checkbox: ${error}`
-            );
-        }
+  'the user selects the {string} option of the {string} dropdown',
+  async function (this: CustomWorld, optionName: string, elementName: SelectorName) {
+    const selector = await resolveLocator(this.page, elementName)
+    if (!selector) {
+      throw new Error(`Selector ${elementName} not found`)
     }
-);
+    try {
+      await this.page.locator(selector).selectOption(optionName)
+    } catch (error) {
+      throw new Error(`Failed to select the ${optionName} option of the ${elementName} dropdown: ${error}`)
+    }
+  },
+)
 
 /**
- * @name fill input with stored value
- * @description Template step for filling an input field with data from a stored variable
+ * @name uncheck
+ * @description Template step for unchecking a checkbox
  * @icon INPUT
  */
-When(
-    'the user fills in the {string} input with data from the stored variable {string}',
-    async function (
-        this: CustomWorld,
-        fieldName: SelectorName,
-        variableName: string
-    ) {
-        const value = this.getVar<string>(variableName);
-        if (!value) {
-            throw new Error(`Variable ${variableName} not found`);
-        }
-        const selector = await resolveLocator(this.page, fieldName);
-        if (!selector) {
-            throw new Error(`Selector ${fieldName} not found`);
-        }
-        try {
-            await this.page.locator(selector).fill(value);
-        } catch (error) {
-            throw new Error(`Failed to fill in the ${fieldName} input field with data from the stored variable ${variableName}: ${error}`);
-        }
-    }
-);
+When('the user unchecks the {string} checkbox', async function (this: CustomWorld, elementName: SelectorName) {
+  const selector = await resolveLocator(this.page, elementName)
+  if (!selector) {
+    throw new Error(`Selector ${elementName} not found`)
+  }
+  try {
+    await this.page.locator(selector).uncheck()
+  } catch (error) {
+    throw new Error(`Failed to uncheck the ${elementName} checkbox: ${error}`)
+  }
+})

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

@@ -4,9 +4,6 @@ import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvir
  * @description Template steps that deals with browser navigation
  * @type ACTION
  */
-
-// This file is generated automatically. Add template steps to this group to generate content.
-
 /**
  * @name navigate to url
  * @description Navigate to the specified URL
@@ -20,29 +17,6 @@ When('the user navigates to the {string} url', async function (this: CustomWorld
   }
 })
 
-/**
- * @name navigate to environment base url
- * @description Navigate to the base url of the selected environment
- * @icon NAVIGATION
- */
-When('the user navigates to the base url of the selected environment', async function (this: CustomWorld) {
-  try {
-    const environment = process.env.ENVIRONMENT as string
-    if (!environment) {
-      throw new Error('Environment is not set')
-    }
-    const environmentConfig = getEnvironment(environment)
-    if (!environmentConfig) {
-      throw new Error(`Environment ${environment} not found`)
-    }
-    await this.page.goto(environmentConfig.baseUrl, {
-      waitUntil: 'domcontentloaded',
-    })
-  } catch (error) {
-    throw new Error(`Failed to navigate to the base url of the selected environment: ${error}`)
-  }
-})
-
 /**
  * @name reload
  * @description Template step for reloading the current page
@@ -69,3 +43,26 @@ When('the user goes back to the previous page', async function (this: CustomWorl
     throw new Error(`Failed to go back to the previous page: ${error}`)
   }
 })
+
+/**
+ * @name navigate to environment base url
+ * @description Navigate to the base url of the selected environment
+ * @icon NAVIGATION
+ */
+When('the user navigates to the base url of the selected environment', async function (this: CustomWorld) {
+  try {
+    const environment = process.env.ENVIRONMENT as string
+    if (!environment) {
+      throw new Error('Environment is not set')
+    }
+    const environmentConfig = getEnvironment(environment)
+    if (!environmentConfig) {
+      throw new Error(`Environment ${environment} not found`)
+    }
+    await this.page.goto(environmentConfig.baseUrl, {
+      waitUntil: 'domcontentloaded',
+    })
+  } catch (error) {
+    throw new Error(`Failed to navigate to the base url of the selected environment: ${error}`)
+  }
+})

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

@@ -5,140 +5,146 @@ 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 generate random first name and save in variable
- * @description Template step for generating a random first name and saving it inside a variable
+ * @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 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}`);
-        }
+  '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 last name and save in variable
- * @description Template step for generating a random last name and saving it inside a variable
+ * @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 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}`);
-        }
+  '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 email and save in variable
- * @description Template step for generating a random email and saving it inside a variable
+ * @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 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}`);
-        }
+  '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 password and save in variable
- * @description Template step for generating a random password and saving it inside a variable
+ * @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 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}`);
-        }
+  '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 phone and save in variable
- * @description Template step for generating a random phone and saving it inside a variable
+ * @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 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}`);
-        }
+  '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 address and save in variable
- * @description Template step for generating a random address and saving it inside a variable
+ * @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 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}`);
-        }
+  '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 unique text and save in variable
- * @description Template step for generating a random unique text and saving it inside a variable
- * @icon DATA   
+ * @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 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}`);
-        }
+  '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 full name and save in variable
- * @description Template step for generating a random full name and saving it inside a variable
+ * @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 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}`);
-        }
+  '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}`,
+      )
     }
-);
+  },
+)