create-appraisejs 0.2.0-alpha.6 → 0.3.0-alpha.0

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

@@ -1,144 +1,144 @@
 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
+ */
+
+// 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}`);
+        }
+    }
 );

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

@@ -1,87 +1,87 @@
 import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvironment, generateRandomData, RandomDataType } from '../../../packages/cucumber-runtime/src/index.js'
-/**
- * @name store
- * @description Template steps that handle data storage
- * @type ACTION
- */
-
-// This file is generated automatically. Add template steps to this group to generate content.
-
-/**
- * @name store element text
- * @description Template step for storing element text inside a data variable to be referenced in later steps
- * @icon STORE
- */
-When(
-  'the user stores the {string} element text inside the variable {string}',
-  async function (
-    this: CustomWorld,
-    elementName: SelectorName,
-    storeVariableName: string
-  ) {
-    const selector = await resolveLocator(this.page, elementName);
-    if (!selector) {
-      throw new Error(`Selector ${elementName} not found`);
-    }
-    try {
-      const text = await this.page.locator(selector).textContent();
-      this.setVar(storeVariableName, text);
-    } catch (error) {
-      throw new Error(
-        `Failed to store the ${elementName} element text: ${error}`
-      );
-    }
-  }
-);
-
-/**
- * @name store text input text
- * @description Template step for storing text input element values inside a variable
- * @icon STORE
- */
-When(
-  'the user stores the {string} text input value inside the variable {string}',
-  async function (
-    this: CustomWorld,
-    fieldName: SelectorName,
-    variableName: string
-  ) {
-    const selector = await resolveLocator(this.page, fieldName);
-    if (!selector) {
-      throw new Error(`Selector ${fieldName} not found`);
-    }
-    try {
-      const value = await this.page.locator(selector).inputValue();
-      this.setVar(variableName, value);
-    } catch (error) {
-      throw new Error(
-        `Failed to store the ${fieldName} text input value: ${error}`
-      );
-    }
-  }
-);
-
-/**
- * @name store textarea text
- * @description Template step for storing textarea content inside a 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 text = await this.page.locator(selector).inputValue();
-      this.setVar(variableName, text);
-    } catch (error) {
-      throw new Error(`Failed to store the ${elementName} textarea input value inside the variable ${variableName}: ${error}`);
-    }
-  }
-);
+/**
+ * @name store
+ * @description Template steps that handle data storage
+ * @type ACTION
+ */
+
+// This file is generated automatically. Add template steps to this group to generate content.
+
+/**
+ * @name store element text
+ * @description Template step for storing element text inside a data variable to be referenced in later steps
+ * @icon STORE
+ */
+When(
+  'the user stores the {string} element text inside the variable {string}',
+  async function (
+    this: CustomWorld,
+    elementName: SelectorName,
+    storeVariableName: string
+  ) {
+    const selector = await resolveLocator(this.page, elementName);
+    if (!selector) {
+      throw new Error(`Selector ${elementName} not found`);
+    }
+    try {
+      const text = await this.page.locator(selector).textContent();
+      this.setVar(storeVariableName, text);
+    } catch (error) {
+      throw new Error(
+        `Failed to store the ${elementName} element text: ${error}`
+      );
+    }
+  }
+);
+
+/**
+ * @name store text input text
+ * @description Template step for storing text input element values inside a variable
+ * @icon STORE
+ */
+When(
+  'the user stores the {string} text input value inside the variable {string}',
+  async function (
+    this: CustomWorld,
+    fieldName: SelectorName,
+    variableName: string
+  ) {
+    const selector = await resolveLocator(this.page, fieldName);
+    if (!selector) {
+      throw new Error(`Selector ${fieldName} not found`);
+    }
+    try {
+      const value = await this.page.locator(selector).inputValue();
+      this.setVar(variableName, value);
+    } catch (error) {
+      throw new Error(
+        `Failed to store the ${fieldName} text input value: ${error}`
+      );
+    }
+  }
+);
+
+/**
+ * @name store textarea text
+ * @description Template step for storing textarea content inside a 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 text = await this.page.locator(selector).inputValue();
+      this.setVar(variableName, text);
+    } catch (error) {
+      throw new Error(`Failed to store the ${elementName} textarea input value inside the variable ${variableName}: ${error}`);
+    }
+  }
+);

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

@@ -1,91 +1,111 @@
 import { When, Then, CustomWorld, expect, SelectorName, resolveLocator, getEnvironment, generateRandomData, RandomDataType } from '../../../packages/cucumber-runtime/src/index.js'
-/**
- * @name wait
- * @description Template steps that handles waiting
- * @type ACTION
- */
-
-// This file is generated automatically. Add template steps to this group to generate content.
-
-/**
- * @name wait for page load
- * @description Template step for waiting till page becomes interactive
- * @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 url route
- * @description Template step for waiting for a url route to be loaded
- * @icon WAIT
- */
-When('the user waits for the route {string} to be loaded', async function (this: CustomWorld, routeName: string) {
-  try {
-    const baseUrl = getEnvironment(process.env.ENVIRONMENT as string).baseUrl
-    const sanitizedBaseUrl = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl
-    const sanitizedRouteName = routeName.startsWith('/') ? routeName.slice(1) : routeName
-    const fullRoute = `${sanitizedBaseUrl}/${sanitizedRouteName}`
-    await this.page.waitForURL(fullRoute, { waitUntil: 'domcontentloaded' })
-  } catch (error) {
-    throw new Error(`Failed to wait for the route ${routeName} to be loaded: ${error}`)
-  }
-})
-
-/**
- * @name wait for element
- * @description Template step for waiting for element to become visible
- * @icon WAIT
- */
-When(
-  'the user waits for the element {string} to become visible',
-  async function (this: CustomWorld, elementName: SelectorName) {
-    try {
-      const selector = await resolveLocator(this.page, elementName)
-      if (!selector) {
-        throw new Error(`Selector ${elementName} not found`)
-      }
-      await this.page.waitForSelector(selector, { 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 Template step for waiting for an element to disappear from viewport
- * @icon WAIT
- */
-When(
-  'the user waits for the {string} element to disappear',
-  async function (this: CustomWorld, elementName: SelectorName) {
-    try {
-      const selector = await resolveLocator(this.page, elementName)
-      if (!selector) {
-        throw new Error(`Selector ${elementName} not found`)
-      }
-      await this.page.waitForSelector(selector, { state: 'hidden' })
-    } catch (error) {
-      throw new Error(`Failed to wait for the ${elementName} element to disappear: ${error}`)
-    }
-  },
-)
-
-/**
- * @name wait for specific amount of seconds
- * @description Template step for waiting for for an specific amount of seconds before proceeding with next action
- * @icon WAIT
- */
-When('the user waits for {int} seconds', async function (this: CustomWorld, waitTimeInSeconds: number) {
-  try {
-    await this.page.waitForTimeout(waitTimeInSeconds * 1000)
-  } catch (error) {
-    throw new Error(`Failed to wait for ${waitTimeInSeconds} seconds: ${error}`)
-  }
-})
+/**
+ * @name wait
+ * @description Template steps that handles waiting
+ * @type ACTION
+ */
+/**
+ * @name wait for page load
+ * @description Template step for waiting till page becomes interactive
+ * @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 url route
+ * @description Template step for waiting for a url route to be loaded
+ * @icon WAIT
+ */
+When(
+  'the user waits for the route {string} to be loaded',
+  async function (this: CustomWorld, routeName: string) {
+    try {
+      const baseUrl = getEnvironment(process.env.ENVIRONMENT as string).baseUrl;
+      const sanitizedBaseUrl = baseUrl.endsWith('/')
+        ? baseUrl.slice(0, -1)
+        : baseUrl;
+      const sanitizedRouteName = routeName.startsWith('/')
+        ? routeName.slice(1)
+        : routeName;
+      const fullRoute = `${sanitizedBaseUrl}/${sanitizedRouteName}`;
+      await this.page.waitForURL(fullRoute, { waitUntil: 'domcontentloaded' });
+    } catch (error) {
+      throw new Error(
+        `Failed to wait for the route ${routeName} to be loaded: ${error}`
+      );
+    }
+  }
+);
+
+/**
+ * @name wait for element
+ * @description Template step for waiting for element to become visible
+ * @icon WAIT
+ */
+When(
+  'the user waits for the element {string} to become visible',
+  async function (this: CustomWorld, elementName: SelectorName) {
+    try {
+      const selector = await resolveLocator(this.page, elementName);
+      if (!selector) {
+        throw new Error(`Selector ${elementName} not found`);
+      }
+      await this.page.waitForSelector(selector, { 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 Template step for waiting for an element to disappear from viewport
+ * @icon WAIT
+ */
+When(
+  'the user waits for the {string} element to disappear',
+  async function (this: CustomWorld, elementName: SelectorName) {
+    try {
+      const selector = await resolveLocator(this.page, elementName);
+      if (!selector) {
+        throw new Error(`Selector ${elementName} not found`);
+      }
+      await this.page.waitForSelector(selector, { state: 'hidden' });
+    } catch (error) {
+      throw new Error(
+        `Failed to wait for the ${elementName} element to disappear: ${error}`
+      );
+    }
+  }
+);
+
+/**
+ * @name wait for specific amount of seconds
+ * @description Template step for waiting for for an specific amount of seconds before proceeding with next action
+ * @icon WAIT
+ */
+When(
+  'the user waits for {int} seconds',
+  async function (this: CustomWorld, waitTimeInSeconds: number) {
+    try {
+      await this.page.waitForTimeout(waitTimeInSeconds * 1000);
+    } catch (error) {
+      throw new Error(
+        `Failed to wait for ${waitTimeInSeconds} seconds: ${error}`
+      );
+    }
+  }
+);