npm - @intuned/browser-dev - Versions diffs - 2.2.3-unify-sdks.20 - Mend

@intuned/browser-dev 2.2.3-unify-sdks.20

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (195) hide show

package/dist/helpers/tests/testSimplifyHtml.spec.js ADDED Viewed

@@ -0,0 +1,251 @@
+"use strict";
+var _extendedTest = require("./extendedTest");
+var _playwrightCore = require("playwright-core");
+var _getSimplifiedHtml = require("../../common/getSimplifiedHtml");
+(0, _extendedTest.describe)("HTML Simplification Tests", () => {
+  let browser;
+  let page;
+  (0, _extendedTest.beforeAll)(async () => {
+    browser = await _playwrightCore.chromium.launch({
+      headless: false
+    });
+  });
+  (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 perform basic HTML simplification", async () => {
+    await page.setContent(`
+      <html>
+      <head><title>Basic Test</title></head>
+      <body>
+          <h1>Main Heading</h1>
+          <p>This is a paragraph with some text content.</p>
+          <div>
+              <span>Nested content</span>
+              <ul>
+                  <li>List item 1</li>
+                  <li>List item 2</li>
+              </ul>
+          </div>
+          <img src="test.jpg" alt="Test image">
+      </body>
+      </html>
+    `);
+    await page.waitForTimeout(1000);
+    const bodyHandle = await page.locator("body").elementHandle();
+    (0, _extendedTest.expect)(bodyHandle).not.toBeNull();
+    const simplifiedHtml = await (0, _getSimplifiedHtml.getSimplifiedHtml)(bodyHandle);
+    console.log(simplifiedHtml);
+    (0, _extendedTest.expect)(simplifiedHtml).toBeTruthy();
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("<body");
+  });
+  (0, _extendedTest.test)("should handle interactive elements", async () => {
+    await page.setContent(`
+      <html>
+      <body>
+          <form>
+              <input type="text" name="username" placeholder="Enter username">
+              <input type="password" name="password" placeholder="Enter password">
+              <textarea name="comments" placeholder="Your comments"></textarea>
+              <select name="country">
+                  <option value="us">United States</option>
+                  <option value="uk">United Kingdom</option>
+              </select>
+              <button type="submit">Submit</button>
+              <button type="button" onclick="alert('clicked')">Click Me</button>
+          </form>
+          <a href="https://example.com">Link to example</a>
+          <div style="cursor: pointer;">Clickable div</div>
+          <span onmousedown="console.log('mouse down')">Mouse event span</span>
+      </body>
+      </html>
+    `);
+    await page.waitForTimeout(2000);
+    const bodyHandle = await page.locator("body").elementHandle();
+    (0, _extendedTest.expect)(bodyHandle).not.toBeNull();
+    const simplifiedHtml = await (0, _getSimplifiedHtml.getSimplifiedHtml)(bodyHandle);
+    console.log(simplifiedHtml);
+    (0, _extendedTest.expect)(simplifiedHtml).toBeTruthy();
+    const lowerHtml = simplifiedHtml.toLowerCase();
+    const hasInteractiveElements = ["input", "button", "textarea"].some(tag => lowerHtml.includes(tag));
+    (0, _extendedTest.expect)(hasInteractiveElements).toBe(true);
+  });
+  (0, _extendedTest.test)("should work with options", async () => {
+    await page.setContent(`
+      <html>
+      <body>
+          <div onclick="handleClick()">Clickable content</div>
+          <button onclick="submitForm()">Submit Form</button>
+          <a href="#" onclick="navigate()">Navigation Link</a>
+          <span onmouseup="handleMouse()">Mouse handler</span>
+          <div onkeydown="handleKey()">Key handler</div>
+          <p>Regular paragraph with lots of text content that should be included as content prop</p>
+          <article>
+              <h2>Article Title</h2>
+              <p>Article content with meaningful text that should be preserved</p>
+          </article>
+      </body>
+      </html>
+    `);
+    await page.waitForTimeout(1000);
+    const bodyHandle = await page.locator("body").elementHandle();
+    (0, _extendedTest.expect)(bodyHandle).not.toBeNull();
+    const simplifiedHtml = await (0, _getSimplifiedHtml.getSimplifiedHtml)(bodyHandle, {
+      shouldIncludeOnClick: true,
+      shouldIncludeContentAsProp: true
+    });
+    console.log(simplifiedHtml);
+    (0, _extendedTest.expect)(simplifiedHtml).toBeTruthy();
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("<body");
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("onclick");
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("content=");
+  });
+  (0, _extendedTest.test)("should filter invisible elements", async () => {
+    await page.setContent(`
+      <html>
+      <body>
+          <div style="display: none;">Hidden div</div>
+          <div>Visible div</div>
+          <button style="visibility: hidden;">Hidden button</button>
+          <button>Visible button</button>
+          <span style="opacity: 0;">Invisible span</span>
+          <span>Visible span</span>
+          <p style="display: block;">Visible paragraph</p>
+      </body>
+      </html>
+    `);
+    const bodyHandle = await page.locator("body").elementHandle();
+    (0, _extendedTest.expect)(bodyHandle).not.toBeNull();
+    const simplifiedHtml = await (0, _getSimplifiedHtml.getSimplifiedHtml)(bodyHandle, {
+      keepOnlyVisibleElements: true
+    });
+    console.log(simplifiedHtml);
+    (0, _extendedTest.expect)(simplifiedHtml.includes("Visible div") || simplifiedHtml.toLowerCase().includes("visible")).toBe(true);
+    (0, _extendedTest.expect)(simplifiedHtml).not.toContain("Hidden div");
+    (0, _extendedTest.expect)(simplifiedHtml).not.toContain("Hidden button");
+    (0, _extendedTest.expect)(simplifiedHtml).not.toContain("Invisible span");
+  });
+  (0, _extendedTest.test)("should handle full HTML element", async () => {
+    await page.setContent(`
+      <html lang="en">
+      <head>
+          <title>Full HTML Test</title>
+          <meta charset="UTF-8">
+      </head>
+      <body>
+          <header>
+              <h1>Website Header</h1>
+              <nav>
+                  <a href="/">Home</a>
+                  <a href="/about">About</a>
+              </nav>
+          </header>
+          <main>
+              <section>
+                  <h2>Main Section</h2>
+                  <p>Main content area</p>
+              </section>
+          </main>
+          <footer>
+              <p>&copy; 2024 Test Site</p>
+          </footer>
+      </body>
+      </html>
+    `);
+    await page.waitForTimeout(1000);
+    const htmlHandle = await page.locator("html").elementHandle();
+    (0, _extendedTest.expect)(htmlHandle).not.toBeNull();
+    const simplifiedHtml = await (0, _getSimplifiedHtml.getSimplifiedHtml)(htmlHandle);
+    console.log(simplifiedHtml);
+    (0, _extendedTest.expect)(simplifiedHtml).toBeTruthy();
+    (0, _extendedTest.expect)(simplifiedHtml.startsWith("<html")).toBe(true);
+  });
+  (0, _extendedTest.test)("should preserve allowed attributes", async () => {
+    await page.setContent(`
+      <html>
+      <body>
+          <div aria-label="Main content area" data-testid="main-div" data-custom="value">
+              <input type="text" name="search" placeholder="Search..." value="test value">
+              <button role="button" title="Submit search">Search</button>
+              <a href="https://example.com" id="main-link">External Link</a>
+              <img src="test.jpg" alt="Test image" data-src="fallback.jpg">
+          </div>
+          <form data-form-id="contact">
+              <input type="email" name="email" placeholder="Your email">
+              <textarea name="message" placeholder="Your message" title="Message field"></textarea>
+          </form>
+      </body>
+      </html>
+    `);
+    const bodyHandle = await page.locator("body").elementHandle();
+    (0, _extendedTest.expect)(bodyHandle).not.toBeNull();
+    const simplifiedHtml = await (0, _getSimplifiedHtml.getSimplifiedHtml)(bodyHandle);
+    console.log(simplifiedHtml);
+    (0, _extendedTest.expect)(simplifiedHtml).toBeTruthy();
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("aria-label=");
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("data-");
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("name=");
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("type=");
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("placeholder=");
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("role=");
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("title=");
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("href=");
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("id=");
+    (0, _extendedTest.expect)(simplifiedHtml).toContain("alt=");
+  });
+  (0, _extendedTest.test)("should handle input elements with values", async () => {
+    await page.setContent(`
+      <html>
+      <body>
+          <form>
+              <input type="text" name="filled" value="has value" style="display: none;">
+              <input type="text" name="empty" value="" style="display: none;">
+              <input type="hidden" name="hidden" value="hidden value">
+              <input type="text" name="visible" value="visible value">
+          </form>
+      </body>
+      </html>
+    `);
+    const bodyHandle = await page.locator("body").elementHandle();
+    (0, _extendedTest.expect)(bodyHandle).not.toBeNull();
+    const simplifiedHtml = await (0, _getSimplifiedHtml.getSimplifiedHtml)(bodyHandle);
+    console.log(simplifiedHtml);
+    (0, _extendedTest.expect)(simplifiedHtml).toBeTruthy();
+    (0, _extendedTest.expect)(simplifiedHtml.includes('value="has value"') || simplifiedHtml.includes("has value")).toBe(true);
+    (0, _extendedTest.expect)(simplifiedHtml.includes('value="hidden value"') || simplifiedHtml.includes("hidden value")).toBe(true);
+  });
+  (0, _extendedTest.test)("should handle iframe elements", async () => {
+    await page.setContent(`
+      <html>
+      <body>
+          <div>Main content</div>
+          <iframe src="about:blank" title="Test iframe">
+              <p>Iframe fallback content</p>
+          </iframe>
+          <div>More content after iframe</div>
+      </body>
+      </html>
+    `);
+    const bodyHandle = await page.locator("body").elementHandle();
+    (0, _extendedTest.expect)(bodyHandle).not.toBeNull();
+    const simplifiedHtmlNoIframe = await (0, _getSimplifiedHtml.getSimplifiedHtml)(bodyHandle, {
+      shouldIncludeIframes: false
+    });
+    const simplifiedHtmlWithIframe = await (0, _getSimplifiedHtml.getSimplifiedHtml)(bodyHandle, {
+      shouldIncludeIframes: true
+    });
+    console.log("Without iframe:", simplifiedHtmlNoIframe);
+    console.log("With iframe:", simplifiedHtmlWithIframe);
+    (0, _extendedTest.expect)(simplifiedHtmlNoIframe).toBeTruthy();
+    (0, _extendedTest.expect)(simplifiedHtmlWithIframe).toBeTruthy();
+    (0, _extendedTest.expect)(simplifiedHtmlNoIframe).toContain("Main content");
+    (0, _extendedTest.expect)(simplifiedHtmlWithIframe).toContain("Main content");
+  });
+});

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

@@ -0,0 +1,380 @@
+"use strict";
+var _types = require("../types");
+var _validateDataUsingSchema = require("../validateDataUsingSchema");
+var _extendedTest = require("./extendedTest");
+(0, _extendedTest.describe)("Data Validation Tests", () => {
+  (0, _extendedTest.describe)("clean_data function", () => {
+    const testCases = [[{
+      name: "test",
+      empty: "",
+      none: null,
+      age: 25
+    }, {
+      name: "test",
+      age: 25
+    }, "should clean object with empty string and null values"], [[{
+      name: "test1",
+      empty: ""
+    }, {
+      name: "test2",
+      none: null
+    }], [{
+      name: "test1"
+    }, {
+      name: "test2"
+    }], "should clean array of objects with empty values"], [{
+      name: "test",
+      nested: {
+        key: "value",
+        empty: ""
+      }
+    }, {
+      name: "test",
+      nested: {
+        key: "value"
+      }
+    }, "should clean nested object with empty values"]];
+    for (const [inputData, expectedOutput, description] of testCases) {
+      (0, _extendedTest.test)(description, async () => {
+        const result = (0, _validateDataUsingSchema.cleanData)(inputData);
+        (0, _extendedTest.expect)(result).toEqual(expectedOutput);
+      });
+    }
+  });
+  (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);
+    });
+  });
+});