@intuned/browser-dev 0.1.4-dev.0

package/dist/helpers/tests/testValidateDataUsingSchema.spec.js

@@ -0,0 +1,342 @@
+"use strict";
+
+var _types = require("../types");
+var _validateDataUsingSchema = require("../validateDataUsingSchema");
+var _extendedTest = require("../../common/extendedTest");
+(0, _extendedTest.describe)("Data Validation Tests", () => {
+  (0, _extendedTest.describe)("validate_data_using_schema function", () => {
+    (0, _extendedTest.test)("should validate data using schema with valid data", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          name: {
+            type: "string"
+          },
+          age: {
+            type: "integer"
+          }
+        },
+        required: ["name", "age"]
+      };
+      const data = {
+        name: "John Doe",
+        age: 30,
+        extra_field: "allowed"
+      };
+      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data,
+        schema
+      })).resolves.not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with invalid data (missing required field)", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          name: {
+            type: "string"
+          },
+          age: {
+            type: "integer"
+          }
+        },
+        required: ["name", "age"]
+      };
+      const invalidData = {
+        name: "John Doe"
+      };
+      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: invalidData,
+        schema
+      })).rejects.toThrow(_types.ValidationError);
+      try {
+        await (0, _validateDataUsingSchema.validateDataUsingSchema)({
+          data: invalidData,
+          schema
+        });
+      } catch (error) {
+        (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
+        (0, _extendedTest.expect)(error.message).toContain("Data validation failed");
+        (0, _extendedTest.expect)(error.data).toEqual(invalidData);
+      }
+    });
+    (0, _extendedTest.test)("should validate data using schema with list of valid objects", async () => {
+      const schema = {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string"
+            },
+            age: {
+              type: "integer"
+            }
+          },
+          required: ["name", "age"]
+        }
+      };
+      const data = [{
+        name: "John Doe",
+        age: 30,
+        extra: "field"
+      }, {
+        name: "Jane Doe",
+        age: 25,
+        other: "value"
+      }];
+      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data,
+        schema
+      })).resolves.not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with list containing invalid object", async () => {
+      const schema = {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string"
+            },
+            age: {
+              type: "integer"
+            }
+          },
+          required: ["name", "age"]
+        }
+      };
+      const invalidData = [{
+        name: "John Doe",
+        age: 30
+      }, {
+        name: "Jane Doe",
+        age: "25"
+      }];
+      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: invalidData,
+        schema
+      })).rejects.toThrow(_types.ValidationError);
+      try {
+        await (0, _validateDataUsingSchema.validateDataUsingSchema)({
+          data: invalidData,
+          schema
+        });
+      } catch (error) {
+        console.log(`exc_info: ${error}`);
+        (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
+        (0, _extendedTest.expect)(error.message).toContain("Data validation failed");
+        (0, _extendedTest.expect)(error.data).toEqual(invalidData);
+      }
+    });
+    (0, _extendedTest.test)("should validate data using schema with attachment custom type", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: "attachment"
+          },
+          name: {
+            type: "string"
+          }
+        },
+        required: ["file", "name"]
+      };
+      const validData = {
+        file: {
+          fileName: "documents/report.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          endpoint: null,
+          suggestedFileName: "Monthly Report.pdf",
+          fileType: "document"
+        },
+        name: "Test File Upload"
+      };
+      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validData,
+        schema
+      })).resolves.not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with invalid attachment custom type", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: "attachment"
+          },
+          name: {
+            type: "string"
+          }
+        },
+        required: ["file", "name"]
+      };
+      const invalidData = {
+        file: {
+          fileName: "documents/report.pdf"
+        },
+        name: "Test File Upload"
+      };
+      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: invalidData,
+        schema
+      })).rejects.toThrow(_types.ValidationError);
+      try {
+        await (0, _validateDataUsingSchema.validateDataUsingSchema)({
+          data: invalidData,
+          schema
+        });
+      } catch (error) {
+        (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
+        (0, _extendedTest.expect)(error.message).toContain("Data validation failed");
+        (0, _extendedTest.expect)(error.message).toContain("does not match custom type 'attachment'");
+        (0, _extendedTest.expect)(error.data).toEqual(invalidData);
+      }
+    });
+    (0, _extendedTest.test)("should validate data using schema with attachment in array", async () => {
+      const schema = {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            file: {
+              type: "attachment"
+            },
+            description: {
+              type: "string"
+            }
+          },
+          required: ["file", "description"]
+        }
+      };
+      const validData = [{
+        file: {
+          fileName: "doc1.pdf",
+          bucket: "bucket1",
+          region: "us-east-1",
+          suggestedFileName: "Document 1.pdf"
+        },
+        description: "First document"
+      }, {
+        file: {
+          fileName: "doc2.pdf",
+          bucket: "bucket2",
+          region: "us-west-2",
+          suggestedFileName: "Document 2.pdf"
+        },
+        description: "Second document"
+      }];
+      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validData,
+        schema
+      })).resolves.not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with invalid attachment in array", async () => {
+      const schema = {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            file: {
+              type: "attachment"
+            },
+            description: {
+              type: "string"
+            }
+          },
+          required: ["file", "description"]
+        }
+      };
+      const invalidData = [{
+        file: {
+          fileName: "doc1.pdf",
+          bucket: "bucket1",
+          region: "us-east-1",
+          suggestedFileName: "Document 1.pdf"
+        },
+        description: "First document"
+      }, {
+        file: {
+          fileName: "doc2.pdf"
+        },
+        description: "Second document"
+      }];
+      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: invalidData,
+        schema
+      })).rejects.toThrow(_types.ValidationError);
+      try {
+        await (0, _validateDataUsingSchema.validateDataUsingSchema)({
+          data: invalidData,
+          schema
+        });
+      } catch (error) {
+        (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
+        (0, _extendedTest.expect)(error.message).toContain("Data validation failed");
+        (0, _extendedTest.expect)(error.message).toContain("does not match custom type 'attachment'");
+        (0, _extendedTest.expect)(error.data).toEqual(invalidData);
+      }
+    });
+    (0, _extendedTest.test)("should handle mixed custom and standard types", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          attachment: {
+            type: "attachment"
+          },
+          title: {
+            type: "string"
+          },
+          count: {
+            type: "integer"
+          },
+          active: {
+            type: "boolean"
+          }
+        },
+        required: ["attachment", "title", "count"]
+      };
+      const validData = {
+        attachment: {
+          fileName: "mixed-test.pdf",
+          bucket: "test-bucket",
+          region: "us-east-1",
+          suggestedFileName: "Mixed Test.pdf"
+        },
+        title: "Mixed validation test",
+        count: 42,
+        active: true
+      };
+      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validData,
+        schema
+      })).resolves.not.toThrow();
+      const invalidStandardData = {
+        attachment: {
+          fileName: "mixed-test.pdf",
+          bucket: "test-bucket",
+          region: "us-east-1",
+          suggestedFileName: "Mixed Test.pdf"
+        },
+        title: "Mixed validation test",
+        count: "not-a-number",
+        active: true
+      };
+      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: invalidStandardData,
+        schema
+      })).rejects.toThrow(_types.ValidationError);
+      const invalidCustomData = {
+        attachment: {
+          fileName: "mixed-test.pdf"
+        },
+        title: "Mixed validation test",
+        count: 42,
+        active: true
+      };
+      await (0, _extendedTest.expect)((0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: invalidCustomData,
+        schema
+      })).rejects.toThrow(_types.ValidationError);
+    });
+  });
+});

package/dist/helpers/tests/testWithDomSettledWait.spec.js

@@ -0,0 +1,164 @@
+"use strict";
+
+var _extendedTest = require("../../common/extendedTest");
+var _ = require("..");
+var _playwrightCore = require("playwright-core");
+var _waitForDomSettled = require("../waitForDomSettled");
+(0, _extendedTest.describe)("Test waitForDomSettled", () => {
+  let browser;
+  let page;
+  (0, _extendedTest.beforeAll)(async () => {
+    browser = await _playwrightCore.chromium.launch({
+      headless: true
+    });
+  });
+  (0, _extendedTest.afterAll)(async () => {
+    await browser.close();
+  });
+  (0, _extendedTest.beforeEach)(async () => {
+    page = await browser.newPage();
+  });
+  (0, _extendedTest.afterEach)(async () => {
+    await page.close();
+  });
+  (0, _extendedTest.test)("should wait for DOM to settle after navigation", async () => {
+    await page.goto("data:text/html,<html><body><div id='target'></div></body></html>");
+    await page.evaluate(() => {
+      const intervalId = setInterval(() => {
+        const target = document.getElementById("target");
+        const div = document.createElement("div");
+        div.textContent = String(Date.now());
+        target === null || target === void 0 || target.appendChild(div);
+        if (target && target.children.length > 10 && target.firstChild) {
+          target.removeChild(target.firstChild);
+        }
+      }, 100);
+      setTimeout(() => {
+        clearInterval(intervalId);
+      }, 5000);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDurationMs: 4000,
+      timeoutInMs: 10000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+  });
+  (0, _extendedTest.test)("should wait for specific element to settle while ignoring other mutations", async () => {
+    await page.goto(`
+      data:text/html,
+      <html>
+        <body>
+          <div id='watched-element'></div>
+          <div id='ignored-element'></div>
+        </body>
+      </html>
+    `);
+    await page.evaluate(() => {
+      const watchedElement = document.getElementById("watched-element");
+      const ignoredElement = document.getElementById("ignored-element");
+      const ignoredInterval = setInterval(() => {
+        const div = document.createElement("div");
+        div.textContent = `Ignored: ${Date.now()}`;
+        ignoredElement === null || ignoredElement === void 0 || ignoredElement.appendChild(div);
+        if (ignoredElement && ignoredElement.children.length > 5 && ignoredElement.firstChild) {
+          ignoredElement.removeChild(ignoredElement.firstChild);
+        }
+      }, 50);
+      const watchedInterval = setInterval(() => {
+        const div = document.createElement("div");
+        div.textContent = `Watched: ${Date.now()}`;
+        watchedElement === null || watchedElement === void 0 || watchedElement.appendChild(div);
+        if (watchedElement && watchedElement.children.length > 3 && watchedElement.firstChild) {
+          watchedElement.removeChild(watchedElement.firstChild);
+        }
+      }, 200);
+      setTimeout(() => {
+        clearInterval(watchedInterval);
+      }, 3000);
+      setTimeout(() => {
+        clearInterval(ignoredInterval);
+      }, 15000);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page.locator("#watched-element"),
+      settleDurationMs: 3000,
+      timeoutInMs: 10000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+  });
+  (0, _extendedTest.test)("should handle no mutations gracefully", async () => {
+    await page.goto("data:text/html,<html><body><div id='target'></div></body></html>");
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page.locator("#target"),
+      settleDurationMs: 3000,
+      timeoutInMs: 10000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+  });
+  _extendedTest.test.skip("should wait for loading to be complete", async () => {
+    await (0, _.goToUrl)({
+      page,
+      url: "https://www.galvestoncountytx.gov/county-offices/purchasing/solicitations-bids",
+      waitForLoadingStateUsingAi: false
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDurationMs: 5000,
+      timeoutInMs: 10000
+    });
+    const loading = await page.getByText("Loading...").isVisible();
+    (0, _extendedTest.expect)(loading).toBe(false);
+  });
+  (0, _extendedTest.test)("should work with manual DOM changes", async () => {
+    await page.goto("data:text/html,<html><body><div id='target'></div></body></html>");
+    await page.evaluate(() => {
+      const target = document.getElementById("target");
+      const div = document.createElement("div");
+      div.textContent = "Added content";
+      target === null || target === void 0 || target.appendChild(div);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDurationMs: 5000,
+      timeoutInMs: 7000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+    const content = await page.textContent("#target");
+    (0, _extendedTest.expect)(content).toContain("Added content");
+  });
+  (0, _extendedTest.test)("should work with custom settle duration", async () => {
+    await page.goto("data:text/html,<html><body><div id='target'></div></body></html>");
+    await page.evaluate(() => {
+      const target = document.getElementById("target");
+      const div = document.createElement("div");
+      div.textContent = "Custom duration content";
+      target === null || target === void 0 || target.appendChild(div);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page,
+      settleDurationMs: 2000,
+      timeoutInMs: 30000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+    const content = await page.textContent("#target");
+    (0, _extendedTest.expect)(content).toContain("Custom duration content");
+  });
+  (0, _extendedTest.test)("should work with locator source", async () => {
+    await page.goto("data:text/html,<html><body><div id='target'></div></body></html>");
+    await page.evaluate(() => {
+      const target = document.getElementById("target");
+      const div = document.createElement("div");
+      div.textContent = "Locator source content";
+      target === null || target === void 0 || target.appendChild(div);
+    });
+    const settled = await (0, _waitForDomSettled.waitForDomSettled)({
+      source: page.locator("#target"),
+      settleDurationMs: 6000,
+      timeoutInMs: 30000
+    });
+    (0, _extendedTest.expect)(settled).toBe(true);
+    const content = await page.textContent("#target");
+    (0, _extendedTest.expect)(content).toContain("Locator source content");
+  });
+});

package/dist/helpers/tests/testWithNetworkIdleWait.spec.js

@@ -0,0 +1,114 @@
+"use strict";
+
+var _extendedTest = require("../../common/extendedTest");
+var _playwright = require("playwright");
+var _ = require("..");
+_extendedTest.describe.skip("TestWaitForNetworkIdle", () => {
+  let browser;
+  let page;
+  (0, _extendedTest.beforeEach)(async () => {
+    browser = await _playwright.chromium.launch({
+      headless: true
+    });
+    page = await browser.newPage();
+  });
+  (0, _extendedTest.afterEach)(async () => {
+    await browser.close();
+  });
+  (0, _extendedTest.test)("wait for network idle click element 1", async () => {
+    await page.goto("https://www.txsmartbuy.gov/esbd?");
+    await page.waitForTimeout(10000);
+    await (0, _.withNetworkSettledWait)(async page => {
+      await page.locator("xpath=(//*[@id='Next'])[1]").first().click({
+        timeout: 10000
+      });
+    }, {
+      page,
+      timeoutInMs: 10000
+    });
+    const currentPage = await page.locator("[aria-label='Current Page']").first().textContent();
+    (0, _extendedTest.expect)(currentPage).toBe("2");
+  });
+  (0, _extendedTest.test)("wait for network idle click element 2", async () => {
+    await page.goto("https://www.biddingo.com/soundtransit", {
+      timeout: 0
+    });
+    await page.waitForTimeout(3000);
+    await (0, _.withNetworkSettledWait)(async page => {
+      await page.locator("[aria-label='Next page']").first().click({
+        timeout: 10000
+      });
+    }, {
+      page,
+      timeoutInMs: 10000
+    });
+    const currentPage = await page.locator(".mat-paginator-range-label").first().textContent();
+    (0, _extendedTest.expect)(currentPage).toContain("11");
+  });
+  (0, _extendedTest.test)("wait for network idle press key combination", async () => {
+    await page.goto("https://www.txsmartbuy.gov/esbd?&page=3");
+    await page.waitForTimeout(10000);
+    await page.click("input[name='agencyNumber']");
+    await (0, _.withNetworkSettledWait)(async page => {
+      await page.keyboard.press("Enter");
+    }, {
+      page,
+      timeoutInMs: 10000
+    });
+    const currentPage = await page.locator("[aria-label='Current Page']").first().textContent();
+    (0, _extendedTest.expect)(currentPage).toBe("1");
+  });
+  (0, _extendedTest.test)("wait for network idle enter text and click", async () => {
+    await page.goto("https://www.txsmartbuy.gov/esbd?&page=3", {
+      timeout: 20000
+    });
+    await page.waitForTimeout(10000);
+    await (0, _.withNetworkSettledWait)(async page => {
+      await page.fill("input[name='agencyNumber']", "123456");
+      await page.click("#content > div > div > form > div.browse-contract-search-actions [type='submit']");
+    }, {
+      page,
+      timeoutInMs: 10000
+    });
+    await page.getByText("No results found", {
+      exact: false
+    }).first().textContent();
+  });
+  (0, _extendedTest.test)("wait for click element 3", async () => {
+    await page.goto("https://www.commbuys.com/bso/view/search/external/advancedSearchBid.xhtml");
+    await page.waitForTimeout(4000);
+    await (0, _.withNetworkSettledWait)(async page => {
+      await page.locator("#bidSearchForm\\:btnBidSearch").first().click({
+        timeout: 10000
+      });
+    }, {
+      page,
+      timeoutInMs: 20000
+    });
+    (0, _extendedTest.expect)(await page.locator("[aria-label='Page 1']").first().isVisible()).toBe(true);
+  });
+  (0, _extendedTest.test)("simple callback usage", async () => {
+    const result = await (0, _.withNetworkSettledWait)(async page => {
+      await page.goto("data:text/html,<html><body><h1>Test</h1></body></html>");
+      return "navigation complete";
+    }, {
+      page
+    });
+    (0, _extendedTest.expect)(result).toBe("navigation complete");
+    const title = await page.textContent("h1");
+    (0, _extendedTest.expect)(title).toBe("Test");
+  });
+  (0, _extendedTest.test)("direct call with callback and options", async () => {
+    const result = await (0, _.withNetworkSettledWait)(async page => {
+      await page.goto("data:text/html,<html><body><h1>Direct Call</h1></body></html>");
+      return "direct call complete";
+    }, {
+      page: page,
+      timeoutInMs: 10000,
+      maxInflightRequests: 0
+    });
+    (0, _extendedTest.expect)(result).toBe("direct call complete");
+    const title = await page.textContent("h1");
+    (0, _extendedTest.expect)(title).toBe("Direct Call");
+  });
+});