create-appraisejs 0.1.6 → 0.1.8-alpha

package/templates/default/src/tests/steps/validations/text_assertion.step.ts

@@ -1,111 +1,111 @@
-/**
- * @name text assertion
- * @description Template steps for asserting text inside elements
- * @type VALIDATION
- */
-import { Then } from '@cucumber/cucumber';
-import { CustomWorld, expect } from '../../config/executor/world.js';
-import { SelectorName } from '@/types/locator/locator.type';
-import { resolveLocator } from '../../utils/locator.util.js';
-
-// This file is generated automatically. Add template steps to this group to generate content.
-
-/**
- * @name assert element contains text
- * @description Template step for validating whether an element contains a certain text or not
- * @icon VALIDATION
- */
-Then(
-  'the element {string} should {boolean} contain the text {string}',
-  async function (
-    this: CustomWorld,
-    elementName: SelectorName,
-    shouldContain: boolean,
-    elementText: string
-  ) {
-    try {
-      const selector = await resolveLocator(this.page, elementName);
-      if (!selector) throw new Error(`Selector ${elementName} not found`);
-      const elementTextContent = await this.page
-        .locator(selector)
-        .textContent();
-
-      if (!elementTextContent)
-        throw new Error(
-          `Element ${elementName} does not have any text content`
-        );
-
-      if (shouldContain) {
-        expect(
-          elementTextContent,
-          `Expected ${elementName} to contain "${elementText}"`
-        ).to.contain(elementText);
-      } else {
-        expect(
-          elementTextContent,
-          `Expected ${elementName} NOT to contain "${elementText}"`
-        ).to.not.contain(elementText);
-      }
-    } catch (error) {
-      throw new Error(
-        `Failed to validate the containment of the text of the element ${elementName}: ${error}`
-      );
-    }
-  }
-);
-
-/**
- * @name assert element equals text
- * @description Template step for validating whether an element text equals a provided text or not
- * @icon VALIDATION
- */
-Then(
-  'the element {string} should {boolean} equal the text {string}',
-  async function (
-    this: CustomWorld,
-    elementName: SelectorName,
-    shouldEqual: boolean,
-    elementText: string
-  ) {
-    try {
-      const selector = await resolveLocator(this.page, elementName);
-      if (!selector) throw new Error(`Selector ${elementName} not found`);
-      const elementTextContent = await this.page
-        .locator(selector)
-        .textContent();
-      if (!elementTextContent)
-        throw new Error(
-          `Element ${elementName} does not have any text content`
-        );
-      if (shouldEqual) {
-        expect(
-          elementTextContent,
-          `Expected ${elementName} to equal "${elementText}"`
-        ).to.equal(elementText);
-      } else {
-        expect(
-          elementTextContent,
-          `Expected ${elementName} NOT to equal "${elementText}"`
-        ).to.not.equal(elementText);
-      }
-    } catch (error) {
-      throw new Error(
-        `Failed to validate the equality of the text of the element ${elementName}: ${error}`
-      );
-    }
-  }
-);
-
-/**
- * @name assert element contains stored variable text
- * @description Template step to validate whether an element text contains the text inside a stored variable
- * @icon VALIDATION
- */
-Then(
-  'the element {string} should contain the text inside the stored variable {string}',
-  async function (
-    this: CustomWorld,
-    _elementName: SelectorName,
-    _variableName: string
-  ) {}
-);
+/**
+ * @name text assertion
+ * @description Template steps for asserting text inside elements
+ * @type VALIDATION
+ */
+import { Then } from '@cucumber/cucumber';
+import { CustomWorld, expect } from '../../config/executor/world.js';
+import { SelectorName } from '@/types/locator/locator.type';
+import { resolveLocator } from '../../utils/locator.util.js';
+
+// This file is generated automatically. Add template steps to this group to generate content.
+
+/**
+ * @name assert element contains text
+ * @description Template step for validating whether an element contains a certain text or not
+ * @icon VALIDATION
+ */
+Then(
+  'the element {string} should {boolean} contain the text {string}',
+  async function (
+    this: CustomWorld,
+    elementName: SelectorName,
+    shouldContain: boolean,
+    elementText: string
+  ) {
+    try {
+      const selector = await resolveLocator(this.page, elementName);
+      if (!selector) throw new Error(`Selector ${elementName} not found`);
+      const elementTextContent = await this.page
+        .locator(selector)
+        .textContent();
+
+      if (!elementTextContent)
+        throw new Error(
+          `Element ${elementName} does not have any text content`
+        );
+
+      if (shouldContain) {
+        expect(
+          elementTextContent,
+          `Expected ${elementName} to contain "${elementText}"`
+        ).to.contain(elementText);
+      } else {
+        expect(
+          elementTextContent,
+          `Expected ${elementName} NOT to contain "${elementText}"`
+        ).to.not.contain(elementText);
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to validate the containment of the text of the element ${elementName}: ${error}`
+      );
+    }
+  }
+);
+
+/**
+ * @name assert element equals text
+ * @description Template step for validating whether an element text equals a provided text or not
+ * @icon VALIDATION
+ */
+Then(
+  'the element {string} should {boolean} equal the text {string}',
+  async function (
+    this: CustomWorld,
+    elementName: SelectorName,
+    shouldEqual: boolean,
+    elementText: string
+  ) {
+    try {
+      const selector = await resolveLocator(this.page, elementName);
+      if (!selector) throw new Error(`Selector ${elementName} not found`);
+      const elementTextContent = await this.page
+        .locator(selector)
+        .textContent();
+      if (!elementTextContent)
+        throw new Error(
+          `Element ${elementName} does not have any text content`
+        );
+      if (shouldEqual) {
+        expect(
+          elementTextContent,
+          `Expected ${elementName} to equal "${elementText}"`
+        ).to.equal(elementText);
+      } else {
+        expect(
+          elementTextContent,
+          `Expected ${elementName} NOT to equal "${elementText}"`
+        ).to.not.equal(elementText);
+      }
+    } catch (error) {
+      throw new Error(
+        `Failed to validate the equality of the text of the element ${elementName}: ${error}`
+      );
+    }
+  }
+);
+
+/**
+ * @name assert element contains stored variable text
+ * @description Template step to validate whether an element text contains the text inside a stored variable
+ * @icon VALIDATION
+ */
+Then(
+  'the element {string} should contain the text inside the stored variable {string}',
+  async function (
+    this: CustomWorld,
+    _elementName: SelectorName,
+    _variableName: string
+  ) {}
+);

package/templates/default/src/tests/steps/validations/visibility_assertion.step.ts

@@ -1,30 +1,30 @@
-/**
- * @name visibility assertion
- * @description Template steps that handles the assertion of element visibility states
- * @type VALIDATION
- */
-import { Then } from '@cucumber/cucumber'
-import { CustomWorld, expect } from '../../config/executor/world.js'
-import { SelectorName } from '@/types/locator/locator.type'
-import { resolveLocator } from '../../utils/locator.util.js'
-
-// This file is generated automatically. Add template steps to this group to generate content.
-
-/**
- * @name assert element visible
- * @description Template step for validating whether an element should be visible or not
- * @icon VALIDATION
- */
-Then(
-  'the visibility status of the {string} element should be {boolean}',
-  async function (this: CustomWorld, elementName: SelectorName, isVisible: boolean) {
-    try {
-      const selector = await resolveLocator(this.page, elementName)
-      if (!selector) throw new Error(`Selector ${elementName} not found`)
-      const elementVisibilityStatus = await this.page.locator(selector).isVisible({ timeout: 10000 })
-      expect(elementVisibilityStatus).to.equal(isVisible)
-    } catch (error) {
-      throw new Error(`Failed to validate the visibility of the element ${elementName}: ${error}`)
-    }
-  },
-)
+/**
+ * @name visibility assertion
+ * @description Template steps that handles the assertion of element visibility states
+ * @type VALIDATION
+ */
+import { Then } from '@cucumber/cucumber'
+import { CustomWorld, expect } from '../../config/executor/world.js'
+import { SelectorName } from '@/types/locator/locator.type'
+import { resolveLocator } from '../../utils/locator.util.js'
+
+// This file is generated automatically. Add template steps to this group to generate content.
+
+/**
+ * @name assert element visible
+ * @description Template step for validating whether an element should be visible or not
+ * @icon VALIDATION
+ */
+Then(
+  'the visibility status of the {string} element should be {boolean}',
+  async function (this: CustomWorld, elementName: SelectorName, isVisible: boolean) {
+    try {
+      const selector = await resolveLocator(this.page, elementName)
+      if (!selector) throw new Error(`Selector ${elementName} not found`)
+      const elementVisibilityStatus = await this.page.locator(selector).isVisible({ timeout: 10000 })
+      expect(elementVisibilityStatus).to.equal(isVisible)
+    } catch (error) {
+      throw new Error(`Failed to validate the visibility of the element ${elementName}: ${error}`)
+    }
+  },
+)

package/templates/default/src/tests/support/parameter-types.ts

@@ -1,12 +1,12 @@
-import { defineParameterType } from '@cucumber/cucumber'
-
-/**
- * Register custom parameter types used in step definitions.
- * Cucumber only has built-in types for {string}, {int}, {float}, {word} —
- * {boolean} must be defined here so steps like "should be true" work.
- */
-defineParameterType({
-  name: 'boolean',
-  regexp: /true|false/,
-  transformer: (s: string) => s === 'true',
-})
+import { defineParameterType } from '@cucumber/cucumber'
+
+/**
+ * Register custom parameter types used in step definitions.
+ * Cucumber only has built-in types for {string}, {int}, {float}, {word} —
+ * {boolean} must be defined here so steps like "should be true" work.
+ */
+defineParameterType({
+  name: 'boolean',
+  regexp: /true|false/,
+  transformer: (s: string) => s === 'true',
+})