@intuned/browser-dev 0.1.9-dev.0 → 0.1.10-dev.0

package/dist/ai/tests/testMatching.spec.js

@@ -0,0 +1,342 @@
+"use strict";
+
+var _extendedTest = require("../../common/extendedTest");
+var _playwright = require("playwright");
+var _matching = require("../../common/matching/matching");
+(0, _extendedTest.describe)("Matching Utility Functions", () => {
+  (0, _extendedTest.describe)("normalizeSpacing", () => {
+    (0, _extendedTest.test)("should replace multiple spaces with single space", async () => {
+      const result = (0, _matching.normalizeSpacing)({
+        text: "hello    world"
+      });
+      (0, _extendedTest.expect)(result).toBe("hello world");
+    });
+    (0, _extendedTest.test)("should replace newlines and tabs with spaces", async () => {
+      const result = (0, _matching.normalizeSpacing)({
+        text: "hello\nworld\tthere"
+      });
+      (0, _extendedTest.expect)(result).toBe("hello world there");
+    });
+    (0, _extendedTest.test)("should handle mixed whitespace", async () => {
+      const result = (0, _matching.normalizeSpacing)({
+        text: "  hello\n\n  world\t\tthere  "
+      });
+      (0, _extendedTest.expect)(result).toBe("hello world there");
+    });
+    (0, _extendedTest.test)("should handle empty string", async () => {
+      const result = (0, _matching.normalizeSpacing)({
+        text: ""
+      });
+      (0, _extendedTest.expect)(result).toBe("");
+    });
+    (0, _extendedTest.test)("should handle string with only whitespace", async () => {
+      const result = (0, _matching.normalizeSpacing)({
+        text: "   \n\t  "
+      });
+      (0, _extendedTest.expect)(result).toBe("");
+    });
+  });
+  (0, _extendedTest.describe)("removePunctuationAndSpaces", () => {
+    (0, _extendedTest.test)("should remove basic punctuation", async () => {
+      const result = (0, _matching.removePunctuationAndSpaces)({
+        s: "Hello, World!"
+      });
+      (0, _extendedTest.expect)(result).toBe("HelloWorld");
+    });
+    (0, _extendedTest.test)("should remove various punctuation marks", async () => {
+      const result = (0, _matching.removePunctuationAndSpaces)({
+        s: "Test@#$%^&*()_+-=[]{}|;':\",./<>?"
+      });
+      (0, _extendedTest.expect)(result).toBe("Test");
+    });
+    (0, _extendedTest.test)("should remove spaces", async () => {
+      const result = (0, _matching.removePunctuationAndSpaces)({
+        s: "hello world there"
+      });
+      (0, _extendedTest.expect)(result).toBe("helloworldthere");
+    });
+    (0, _extendedTest.test)("should handle mixed content", async () => {
+      const result = (0, _matching.removePunctuationAndSpaces)({
+        s: "Hello, World! How are you?"
+      });
+      (0, _extendedTest.expect)(result).toBe("HelloWorldHowareyou");
+    });
+    (0, _extendedTest.test)("should handle empty string", async () => {
+      const result = (0, _matching.removePunctuationAndSpaces)({
+        s: ""
+      });
+      (0, _extendedTest.expect)(result).toBe("");
+    });
+  });
+  (0, _extendedTest.describe)("rankMatch", () => {
+    (0, _extendedTest.test)("should rank exact match as HIGH", async () => {
+      const result = (0, _matching.rankMatch)({
+        original: "Hello World",
+        match: "Hello World"
+      });
+      (0, _extendedTest.expect)(result).toBe("HIGH");
+    });
+    (0, _extendedTest.test)("should rank case insensitive match as HIGH", async () => {
+      const result = (0, _matching.rankMatch)({
+        original: "Hello World",
+        match: "hello world"
+      });
+      (0, _extendedTest.expect)(result).toBe("HIGH");
+    });
+    (0, _extendedTest.test)("should rank match with punctuation differences as HIGH", async () => {
+      const result = (0, _matching.rankMatch)({
+        original: "Hello, World!",
+        match: "Hello World"
+      });
+      (0, _extendedTest.expect)(result).toBe("HIGH");
+    });
+    (0, _extendedTest.test)("should rank long string with high similarity as HIGH", async () => {
+      const original = "This is a very long string with more than twenty characters";
+      const match = "This is a very long string with more than twenty character";
+      const result = (0, _matching.rankMatch)({
+        original,
+        match
+      });
+      (0, _extendedTest.expect)(result).toBe("HIGH");
+    });
+    (0, _extendedTest.test)("should rank completely different strings as LOW", async () => {
+      const result = (0, _matching.rankMatch)({
+        original: "Hello World",
+        match: "Goodbye Universe"
+      });
+      (0, _extendedTest.expect)(result).toBe("LOW");
+    });
+    (0, _extendedTest.test)("should rank short string partial match as LOW", async () => {
+      const result = (0, _matching.rankMatch)({
+        original: "Hello",
+        match: "Hell"
+      });
+      (0, _extendedTest.expect)(result).toBe("LOW");
+    });
+  });
+  (0, _extendedTest.describe)("selectBestMatch", () => {
+    (0, _extendedTest.test)("should prefer exact match over fuzzy match", async () => {
+      const matches = [{
+        matched_value: "Hello Worlds",
+        match_mode: "fuzzy",
+        fuzzy_distance: 1,
+        match_source: "text_content",
+        xpath: "/html/body/div[1]"
+      }, {
+        matched_value: "Hello World",
+        match_mode: "full",
+        fuzzy_distance: 0,
+        match_source: "text_content",
+        xpath: "/html/body/div[2]"
+      }];
+      const result = (0, _matching.selectBestMatch)({
+        original: "Hello World",
+        matches
+      });
+      (0, _extendedTest.expect)(result === null || result === void 0 ? void 0 : result.matchText).toBe("Hello World");
+    });
+    (0, _extendedTest.test)("should select fuzzy match based on distance", async () => {
+      const matches = [{
+        matched_value: "Hello Worlds",
+        match_mode: "fuzzy",
+        fuzzy_distance: 1,
+        match_source: "text_content",
+        xpath: "/html/body/div[1]"
+      }, {
+        matched_value: "Hello World!",
+        match_mode: "fuzzy",
+        fuzzy_distance: 0.5,
+        match_source: "text_content",
+        xpath: "/html/body/div[2]"
+      }, {
+        matched_value: "Hello Worldz",
+        match_mode: "fuzzy",
+        fuzzy_distance: 2,
+        match_source: "text_content",
+        xpath: "/html/body/div[3]"
+      }];
+      const result = (0, _matching.selectBestMatch)({
+        original: "Hello World",
+        matches
+      });
+      (0, _extendedTest.expect)(result === null || result === void 0 ? void 0 : result.matchText).toBe("Hello World!");
+    });
+    (0, _extendedTest.test)("should return null when no good matches found", async () => {
+      const matches = [{
+        matched_value: "Completely Different",
+        match_mode: "fuzzy",
+        fuzzy_distance: 10,
+        match_source: "text_content",
+        xpath: "/html/body/div[1]"
+      }];
+      const result = (0, _matching.selectBestMatch)({
+        original: "Hello World",
+        matches
+      });
+      (0, _extendedTest.expect)(result).toBeNull();
+    });
+    (0, _extendedTest.test)("should return null with empty matches list", async () => {
+      const result = (0, _matching.selectBestMatch)({
+        original: "Hello World",
+        matches: []
+      });
+      (0, _extendedTest.expect)(result).toBeNull();
+    });
+    (0, _extendedTest.test)("should select first exact match when multiple exist", async () => {
+      const matches = [{
+        matched_value: "Hello World!",
+        match_mode: "full",
+        fuzzy_distance: 0,
+        match_source: "text_content",
+        xpath: "/html/body/div[1]"
+      }, {
+        matched_value: "Hello World",
+        match_mode: "full",
+        fuzzy_distance: 0,
+        match_source: "text_content",
+        xpath: "/html/body/div[2]"
+      }, {
+        matched_value: "HELLO WORLD",
+        match_mode: "full",
+        fuzzy_distance: 0,
+        match_source: "text_content",
+        xpath: "/html/body/div[3]"
+      }];
+      const result = (0, _matching.selectBestMatch)({
+        original: "Hello World",
+        matches
+      });
+      (0, _extendedTest.expect)(result === null || result === void 0 ? void 0 : result.matchText).toBe("Hello World!");
+    });
+    (0, _extendedTest.test)("should return null for low ranked fuzzy matches only", async () => {
+      const matches = [{
+        matched_value: "Completely Different Text",
+        match_mode: "fuzzy",
+        fuzzy_distance: 0.5,
+        match_source: "text_content",
+        xpath: "/html/body/div[1]"
+      }, {
+        matched_value: "Another Unrelated String",
+        match_mode: "fuzzy",
+        fuzzy_distance: 1,
+        match_source: "text_content",
+        xpath: "/html/body/div[2]"
+      }, {
+        matched_value: "Not Even Close",
+        match_mode: "fuzzy",
+        fuzzy_distance: 0.2,
+        match_source: "text_content",
+        xpath: "/html/body/div[3]"
+      }];
+      const result = (0, _matching.selectBestMatch)({
+        original: "Hello World",
+        matches
+      });
+      (0, _extendedTest.expect)(result).toBeNull();
+    });
+    (0, _extendedTest.test)("should handle partial match mode with exact matches", async () => {
+      const matches = [{
+        matched_value: "Hello",
+        match_mode: "partial",
+        fuzzy_distance: 0,
+        match_source: "text_content",
+        xpath: "/html/body/div[1]"
+      }, {
+        matched_value: "Hello Worlds",
+        match_mode: "fuzzy",
+        fuzzy_distance: 1,
+        match_source: "text_content",
+        xpath: "/html/body/div[2]"
+      }, {
+        matched_value: "World",
+        match_mode: "partial",
+        fuzzy_distance: 0,
+        match_source: "text_content",
+        xpath: "/html/body/div[3]"
+      }];
+      const result = (0, _matching.selectBestMatch)({
+        original: "Hello World",
+        matches
+      });
+      (0, _extendedTest.expect)(result === null || result === void 0 ? void 0 : result.matchText).toBe("Hello");
+    });
+  });
+  (0, _extendedTest.describe)("matchStringsWithDomContent", () => {
+    let browser;
+    let page;
+    (0, _extendedTest.beforeAll)(async () => {
+      browser = await _playwright.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 match basic strings in DOM content", async () => {
+      await page.setContent(`
+        <html>
+          <body>
+            <h1>Hello World</h1>
+            <p>This is a test paragraph</p>
+            <span>Another test element</span>
+          </body>
+        </html>
+      `);
+      const stringsToMatch = ["Hello World", "test paragraph", "Another test"];
+      const matches = await (0, _matching.matchStringsWithDomContent)({
+        pageObject: page,
+        stringsList: stringsToMatch
+      });
+      (0, _extendedTest.expect)(matches).toHaveProperty("Hello World");
+      (0, _extendedTest.expect)(matches).toHaveProperty("test paragraph");
+      (0, _extendedTest.expect)(matches).toHaveProperty("Another test");
+    });
+    (0, _extendedTest.test)("should match strings in iframe content", async () => {
+      await page.setContent(`
+        <html>
+          <body>
+            <h1>Main Page Header</h1>
+            <p>Content before iframe</p>
+            <iframe id="test-iframe" srcdoc="<html><body><h2>Iframe Header</h2><p>Content inside iframe</p><span>Iframe text to match</span></body></html>"></iframe>
+            <p>Content after iframe</p>
+          </body>
+        </html>
+      `);
+      await page.waitForSelector("#test-iframe");
+      await page.frameLocator("#test-iframe").locator("body").waitFor();
+      const stringsToMatch = ["Main Page Header", "Content before iframe", "Iframe Header", "Content inside iframe", "Iframe text to match", "Content after iframe"];
+      const matches = await (0, _matching.matchStringsWithDomContent)({
+        pageObject: page,
+        stringsList: stringsToMatch
+      });
+      (0, _extendedTest.expect)(matches).toHaveProperty("Main Page Header");
+      (0, _extendedTest.expect)(matches["Main Page Header"].length).toBeGreaterThan(0);
+      (0, _extendedTest.expect)(matches).toHaveProperty("Content before iframe");
+      (0, _extendedTest.expect)(matches["Content before iframe"].length).toBeGreaterThan(0);
+      (0, _extendedTest.expect)(matches).toHaveProperty("Iframe Header");
+      (0, _extendedTest.expect)(matches["Iframe Header"].length).toBeGreaterThan(0);
+      (0, _extendedTest.expect)(matches).toHaveProperty("Content inside iframe");
+      (0, _extendedTest.expect)(matches["Content inside iframe"].length).toBeGreaterThan(0);
+      (0, _extendedTest.expect)(matches).toHaveProperty("Iframe text to match");
+      (0, _extendedTest.expect)(matches["Iframe text to match"].length).toBeGreaterThan(0);
+      (0, _extendedTest.expect)(matches).toHaveProperty("Content after iframe");
+      (0, _extendedTest.expect)(matches["Content after iframe"].length).toBeGreaterThan(0);
+    });
+    (0, _extendedTest.test)("should handle error gracefully", async () => {
+      const stringsToMatch = ["Some text"];
+      const matches = await (0, _matching.matchStringsWithDomContent)({
+        pageObject: page,
+        stringsList: stringsToMatch
+      });
+      (0, _extendedTest.expect)(matches).toEqual({
+        "Some text": []
+      });
+    });
+  });
+});

package/dist/ai/tests/testValidateMatchesMapping.spec.js

@@ -0,0 +1,265 @@
+"use strict";
+
+var _extendedTest = require("../../common/extendedTest");
+var _playwright = require("playwright");
+var _matching = require("../../common/matching/matching");
+const PRODUCT_V1_HTML = `
+<html>
+<body>
+  <div class="product">
+    <h2 class="title">iPhone 14 Pro</h2>
+    <div class="price">$999</div>
+    <div class="stock">In Stock</div>
+  </div>
+</body>
+</html>
+`;
+const PRODUCT_V2_MODIFIED_CONTENT = `
+<html>
+<body>
+  <div class="product">
+    <h2 class="title">iPhone 15 Pro</h2>
+    <div class="price">$1099</div>
+    <div class="stock">In Stock</div>
+  </div>
+</body>
+</html>
+`;
+const PRODUCT_WITH_FOOTER = `
+<html>
+<body>
+  <div class="product">
+    <h2 class="title">iPhone 14 Pro</h2>
+    <div class="price">$999</div>
+    <div class="stock">In Stock</div>
+  </div>
+  <footer>
+    <div class="copyright">© 2024 Store</div>
+    <div class="links">Privacy | Terms</div>
+  </footer>
+</body>
+</html>
+`;
+const PRODUCT_WITH_HEADER = `
+<html>
+<body>
+  <header>
+    <div class="banner">New Arrival!</div>
+  </header>
+  <div class="product">
+    <h2 class="title">iPhone 14 Pro</h2>
+    <div class="price">$999</div>
+    <div class="stock">In Stock</div>
+  </div>
+</body>
+</html>
+`;
+const IFRAME_V1_HTML = `
+<html>
+<body>
+  <div class="product">
+    <h2 class="title">iPhone 14 Pro</h2>
+    <div class="price">$999</div>
+  </div>
+  <iframe id="details-frame" srcdoc='
+    <html>
+      <body>
+        <div class="stock">In Stock</div>
+        <div class="rating">4.5 stars</div>
+      </body>
+    </html>
+  '></iframe>
+</body>
+</html>
+`;
+const IFRAME_V2_MODIFIED_IFRAME = `
+<html>
+<body>
+  <div class="product">
+    <h2 class="title">iPhone 14 Pro</h2>
+    <div class="price">$999</div>
+  </div>
+  <iframe id="details-frame" srcdoc='
+    <html>
+      <body>
+        <div class="stock">Out of Stock</div>
+        <div class="rating">4.5 stars</div>
+      </body>
+    </html>
+  '></iframe>
+</body>
+</html>
+`;
+const IFRAME_WITH_EXTRA_CONTENT = `
+<html>
+<body>
+  <div class="product">
+    <h2 class="title">iPhone 14 Pro</h2>
+    <div class="price">$999</div>
+  </div>
+  <iframe id="details-frame" srcdoc='
+    <html>
+      <body>
+        <div class="stock">In Stock</div>
+        <div class="rating">4.5 stars</div>
+        <div class="reviews">100+ reviews</div>
+      </body>
+    </html>
+  '></iframe>
+</body>
+</html>
+`;
+(0, _extendedTest.describe)("validateMatchesMapping", () => {
+  let browser;
+  let page;
+  (0, _extendedTest.beforeAll)(async () => {
+    browser = await _playwright.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 return true when content hasn't changed", async () => {
+    await page.setContent(PRODUCT_V1_HTML);
+    const extractedData = {
+      title: "iPhone 14 Pro",
+      price: "$999",
+      stock: "In Stock"
+    };
+    const cachedMapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    const isValid = await (0, _matching.validateMatchesMapping)(page, cachedMapping);
+    (0, _extendedTest.expect)(isValid).toBe(true);
+  });
+  (0, _extendedTest.test)("should return false when extracted content changes", async () => {
+    await page.setContent(PRODUCT_V1_HTML);
+    const extractedData = {
+      title: "iPhone 14 Pro",
+      price: "$999"
+    };
+    const cachedMapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    await page.setContent(PRODUCT_V2_MODIFIED_CONTENT);
+    const isValid = await (0, _matching.validateMatchesMapping)(page, cachedMapping);
+    (0, _extendedTest.expect)(isValid).toBe(false);
+  });
+  (0, _extendedTest.test)("should return true when irrelevant elements are added (footer)", async () => {
+    await page.setContent(PRODUCT_V1_HTML);
+    const extractedData = {
+      title: "iPhone 14 Pro",
+      price: "$999"
+    };
+    const cachedMapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    await page.setContent(PRODUCT_WITH_FOOTER);
+    const isValid = await (0, _matching.validateMatchesMapping)(page, cachedMapping);
+    (0, _extendedTest.expect)(isValid).toBe(true);
+  });
+  (0, _extendedTest.test)("should return true when header is added at top of page", async () => {
+    await page.setContent(PRODUCT_V1_HTML);
+    const extractedData = {
+      title: "iPhone 14 Pro",
+      price: "$999"
+    };
+    const cachedMapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    await page.setContent(PRODUCT_WITH_HEADER);
+    const isValid = await (0, _matching.validateMatchesMapping)(page, cachedMapping);
+    (0, _extendedTest.expect)(isValid).toBe(true);
+  });
+  (0, _extendedTest.test)("should work with unchanged iframe content", async () => {
+    await page.setContent(IFRAME_V1_HTML);
+    await page.waitForSelector("#details-frame");
+    const extractedData = {
+      title: "iPhone 14 Pro",
+      price: "$999",
+      stock: "In Stock",
+      rating: "4.5 stars"
+    };
+    const cachedMapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    const isValid = await (0, _matching.validateMatchesMapping)(page, cachedMapping);
+    (0, _extendedTest.expect)(isValid).toBe(true);
+  });
+  (0, _extendedTest.test)("should return false when iframe content changes", async () => {
+    await page.setContent(IFRAME_V1_HTML);
+    await page.waitForSelector("#details-frame");
+    const extractedData = {
+      stock: "In Stock",
+      rating: "4.5 stars"
+    };
+    const cachedMapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    await page.setContent(IFRAME_V2_MODIFIED_IFRAME);
+    await page.waitForSelector("#details-frame");
+    const isValid = await (0, _matching.validateMatchesMapping)(page, cachedMapping);
+    (0, _extendedTest.expect)(isValid).toBe(false);
+  });
+  (0, _extendedTest.test)("should return true when extra content is added to iframe", async () => {
+    await page.setContent(IFRAME_V1_HTML);
+    await page.waitForSelector("#details-frame");
+    const extractedData = {
+      stock: "In Stock",
+      rating: "4.5 stars"
+    };
+    const cachedMapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    await page.setContent(IFRAME_WITH_EXTRA_CONTENT);
+    await page.waitForSelector("#details-frame");
+    const isValid = await (0, _matching.validateMatchesMapping)(page, cachedMapping);
+    (0, _extendedTest.expect)(isValid).toBe(true);
+  });
+  (0, _extendedTest.test)("should return false when only some extracted values change", async () => {
+    await page.setContent(PRODUCT_V1_HTML);
+    const extractedData = {
+      title: "iPhone 14 Pro",
+      price: "$999",
+      stock: "In Stock"
+    };
+    const cachedMapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    await page.setContent(PRODUCT_V2_MODIFIED_CONTENT);
+    const isValid = await (0, _matching.validateMatchesMapping)(page, cachedMapping);
+    (0, _extendedTest.expect)(isValid).toBe(false);
+  });
+  (0, _extendedTest.test)("should return true for empty mapping", async () => {
+    await page.setContent(PRODUCT_V1_HTML);
+    const emptyMapping = {};
+    const isValid = await (0, _matching.validateMatchesMapping)(page, emptyMapping);
+    (0, _extendedTest.expect)(isValid).toBe(true);
+  });
+  (0, _extendedTest.test)("should return false when page content is completely different", async () => {
+    await page.setContent(PRODUCT_V1_HTML);
+    const extractedData = {
+      title: "iPhone 14 Pro",
+      price: "$999"
+    };
+    const cachedMapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    const differentPage = `
+    <html>
+    <body>
+      <div class="article">
+        <h1>About Us</h1>
+        <p>We are a company...</p>
+      </div>
+    </body>
+    </html>
+    `;
+    await page.setContent(differentPage);
+    const isValid = await (0, _matching.validateMatchesMapping)(page, cachedMapping);
+    (0, _extendedTest.expect)(isValid).toBe(false);
+  });
+  (0, _extendedTest.test)("should be consistent across multiple calls", async () => {
+    await page.setContent(PRODUCT_V1_HTML);
+    const extractedData = {
+      title: "iPhone 14 Pro",
+      price: "$999"
+    };
+    const cachedMapping = await (0, _matching.createMatchesMapping)(page, extractedData);
+    const isValid1 = await (0, _matching.validateMatchesMapping)(page, cachedMapping);
+    const isValid2 = await (0, _matching.validateMatchesMapping)(page, cachedMapping);
+    const isValid3 = await (0, _matching.validateMatchesMapping)(page, cachedMapping);
+    (0, _extendedTest.expect)(isValid1).toBe(true);
+    (0, _extendedTest.expect)(isValid2).toBe(true);
+    (0, _extendedTest.expect)(isValid3).toBe(true);
+  });
+});