@intuned/browser-dev 0.1.4-dev.1 → 0.1.5-dev.1

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

@@ -37,6 +37,16 @@ const content = `
         <a href="https://intuned-docs-public-images.s3.us-west-2.amazonaws.com/large_pdf.pdf">Download Text File</a>
     </div>
 
+    <div>
+        <h3>Print Dialog Download</h3>
+        <button id="print-button">Print Document</button>
+        <script>
+            document.getElementById('print-button').addEventListener('click', function() {
+                window.print();
+            });
+        </script>
+    </div>
+
 </body>
 </html>
 `;
@@ -56,14 +66,14 @@ async function createUserDirWithPreferences() {
   await (0, _promises.writeFile)(preferencesPath, JSON.stringify(preferences));
   return (0, _path.resolve)(userDir);
 }
-_extendedTest.describe.skip("TestNotInGeneration", () => {
+(0, _extendedTest.describe)("TestNotInGeneration", () => {
   let context;
   let page;
   (0, _extendedTest.beforeAll)(async () => {
     const dir = await createUserDirWithPreferences();
     process.env.MODE = "";
     context = await _playwrightCore.chromium.launchPersistentContext(dir, {
-      headless: true,
+      headless: false,
       args: ["--no-first-run", "--disable-sync", "--disable-translate", "--disable-features=TranslateUI", "--disable-features=NetworkService", "--lang=en", "--disable-blink-features=AutomationControlled"],
       acceptDownloads: true
     });
@@ -97,7 +107,7 @@ _extendedTest.describe.skip("TestNotInGeneration", () => {
     (0, _extendedTest.expect)(path).toBeDefined();
     (0, _extendedTest.expect)(String(path)).toContain("/var/folders/");
   });
-  _extendedTest.test.skip("should upload image to s3", async () => {
+  (0, _extendedTest.test)("should upload image to s3", async () => {
     await page.setContent(content);
     const downloadedImage = await (0, _.downloadFile)({
       page,
@@ -120,7 +130,7 @@ _extendedTest.describe.skip("TestNotInGeneration", () => {
     (0, _extendedTest.expect)(uploadedFile.suggestedFileName).toBeDefined();
     (0, _extendedTest.expect)(uploadedFile.bucket).toBe(process.env.INTUNED_S3_BUCKET);
   });
-  _extendedTest.test.skip("should upload file to s3", async () => {
+  (0, _extendedTest.test)("should upload file to s3", async () => {
     await page.setContent(content);
     const download = await (0, _.downloadFile)({
       page,
@@ -133,6 +143,18 @@ _extendedTest.describe.skip("TestNotInGeneration", () => {
     (0, _extendedTest.expect)(uploadedFile.suggestedFileName).toBeDefined();
     (0, _extendedTest.expect)(uploadedFile.bucket).toBe(process.env.INTUNED_S3_BUCKET);
   });
+  (0, _extendedTest.test)("should download from print dialog", async () => {
+    await page.setContent(content);
+    const printButton = page.locator("#print-button");
+    const download = await (0, _.downloadFile)({
+      page,
+      trigger: printButton
+    });
+    (0, _extendedTest.expect)(download).toBeDefined();
+    const downloadPath = await download.path();
+    (0, _extendedTest.expect)(downloadPath).toBeDefined();
+    (0, _extendedTest.expect)(download.suggestedFilename()).toContain(".pdf");
+  });
 });
 (0, _extendedTest.describe)("TestInGeneration", () => {
   let context;
@@ -141,7 +163,7 @@ _extendedTest.describe.skip("TestNotInGeneration", () => {
     process.env.MODE = "generate_code";
     const dir = await createUserDirWithPreferences();
     context = await _playwrightCore.chromium.launchPersistentContext(dir, {
-      headless: true,
+      headless: false,
       userAgent: "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36",
       args: ["--no-first-run", "--disable-sync", "--disable-translate", "--disable-features=TranslateUI", "--disable-features=NetworkService", "--lang=en", "--disable-blink-features=AutomationControlled"],
       acceptDownloads: true
@@ -188,7 +210,7 @@ _extendedTest.describe.skip("TestNotInGeneration", () => {
     });
     (0, _extendedTest.expect)(downloadedImage.path).toBeDefined();
   });
-  _extendedTest.test.skip("should upload file to s3", async () => {
+  (0, _extendedTest.test)("should upload file to s3", async () => {
     await page.setContent(content);
     const download = await (0, _.downloadFile)({
       page,
@@ -203,4 +225,17 @@ _extendedTest.describe.skip("TestNotInGeneration", () => {
     (0, _extendedTest.expect)(uploadedFile.bucket).toBe("testing_bucket");
     (0, _extendedTest.expect)(uploadedFile.region).toBe("testing_region");
   });
+  (0, _extendedTest.test)("should download from print dialog", async () => {
+    await page.setContent(content);
+    const printButton = page.locator("#print-button");
+    const download = await (0, _.downloadFile)({
+      page,
+      trigger: printButton
+    });
+    (0, _extendedTest.expect)(download).toBeDefined();
+    const cancelled = await download.failure();
+    if (cancelled) {
+      (0, _extendedTest.expect)(cancelled).toContain("canceled");
+    }
+  });
 });

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

@@ -0,0 +1,482 @@
+"use strict";
+
+var _extendedTest = require("../../common/extendedTest");
+var _validateDataUsingSchema = require("../validateDataUsingSchema");
+(0, _extendedTest.describe)("injectAttachmentType Tests", () => {
+  (0, _extendedTest.describe)("Basic attachment injection", () => {
+    (0, _extendedTest.test)("should replace simple attachment type with $ref", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: "attachment"
+          },
+          name: {
+            type: "string"
+          }
+        }
+      };
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(result.$defs).toBeDefined();
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+      (0, _extendedTest.expect)(result.$defs.attachment.type).toBe("object");
+      (0, _extendedTest.expect)(result.properties.file).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.name).toEqual({
+        type: "string"
+      });
+    });
+    (0, _extendedTest.test)("should handle multiple attachment fields in same object", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          document: {
+            type: "attachment"
+          },
+          image: {
+            type: "attachment"
+          },
+          video: {
+            type: "attachment"
+          },
+          title: {
+            type: "string"
+          },
+          count: {
+            type: "integer"
+          }
+        },
+        required: ["document", "title"]
+      };
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(result.properties.document).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.image).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.video).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.title).toEqual({
+        type: "string"
+      });
+      (0, _extendedTest.expect)(result.properties.count).toEqual({
+        type: "integer"
+      });
+      (0, _extendedTest.expect)(result.required).toEqual(["document", "title"]);
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+    });
+  });
+  (0, _extendedTest.describe)("Nested object attachment injection", () => {
+    (0, _extendedTest.test)("should replace attachments in deeply nested objects", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          user: {
+            type: "object",
+            properties: {
+              profile: {
+                type: "object",
+                properties: {
+                  avatar: {
+                    type: "attachment"
+                  },
+                  resume: {
+                    type: "attachment"
+                  },
+                  name: {
+                    type: "string"
+                  }
+                }
+              },
+              settings: {
+                type: "object",
+                properties: {
+                  theme: {
+                    type: "string"
+                  }
+                }
+              }
+            }
+          },
+          metadata: {
+            type: "object",
+            properties: {
+              banner: {
+                type: "attachment"
+              }
+            }
+          }
+        }
+      };
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(result.properties.user.properties.profile.properties.avatar).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.user.properties.profile.properties.resume).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.metadata.properties.banner).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.user.properties.profile.properties.name).toEqual({
+        type: "string"
+      });
+      (0, _extendedTest.expect)(result.properties.user.properties.settings.properties.theme).toEqual({
+        type: "string"
+      });
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+    });
+    (0, _extendedTest.test)("should handle attachments in objects with complex nested structures", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          data: {
+            type: "object",
+            properties: {
+              files: {
+                type: "object",
+                properties: {
+                  primary: {
+                    type: "attachment"
+                  },
+                  secondary: {
+                    type: "object",
+                    properties: {
+                      backup: {
+                        type: "attachment"
+                      },
+                      archive: {
+                        type: "attachment"
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(result.properties.data.properties.files.properties.primary).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.data.properties.files.properties.secondary.properties.backup).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.data.properties.files.properties.secondary.properties.archive).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+    });
+  });
+  (0, _extendedTest.describe)("Array attachment injection", () => {
+    (0, _extendedTest.test)("should replace attachments in array items", async () => {
+      const schema = {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            file: {
+              type: "attachment"
+            },
+            description: {
+              type: "string"
+            }
+          }
+        }
+      };
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(result.items.properties.file).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.items.properties.description).toEqual({
+        type: "string"
+      });
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+    });
+    (0, _extendedTest.test)("should handle arrays of arrays with attachments", async () => {
+      const schema = {
+        type: "array",
+        items: {
+          type: "array",
+          items: {
+            type: "object",
+            properties: {
+              media: {
+                type: "attachment"
+              },
+              caption: {
+                type: "string"
+              }
+            }
+          }
+        }
+      };
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(result.items.items.properties.media).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.items.items.properties.caption).toEqual({
+        type: "string"
+      });
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+    });
+    (0, _extendedTest.test)("should handle object with array of objects containing attachments", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          documents: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                file: {
+                  type: "attachment"
+                },
+                metadata: {
+                  type: "object",
+                  properties: {
+                    thumbnail: {
+                      type: "attachment"
+                    },
+                    title: {
+                      type: "string"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          title: {
+            type: "string"
+          }
+        }
+      };
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(result.properties.documents.items.properties.file).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.documents.items.properties.metadata.properties.thumbnail).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.documents.items.properties.metadata.properties.title).toEqual({
+        type: "string"
+      });
+      (0, _extendedTest.expect)(result.properties.title).toEqual({
+        type: "string"
+      });
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+    });
+  });
+  (0, _extendedTest.describe)("Complex mixed scenarios", () => {
+    (0, _extendedTest.test)("should handle oneOf/anyOf with attachments", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          content: {
+            oneOf: [{
+              type: "object",
+              properties: {
+                text: {
+                  type: "string"
+                }
+              }
+            }, {
+              type: "object",
+              properties: {
+                file: {
+                  type: "attachment"
+                }
+              }
+            }]
+          },
+          fallback: {
+            anyOf: [{
+              type: "string"
+            }, {
+              type: "object",
+              properties: {
+                backup: {
+                  type: "attachment"
+                }
+              }
+            }]
+          }
+        }
+      };
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(result.properties.content.oneOf[0].properties.text).toEqual({
+        type: "string"
+      });
+      (0, _extendedTest.expect)(result.properties.content.oneOf[1].properties.file).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.fallback.anyOf[0]).toEqual({
+        type: "string"
+      });
+      (0, _extendedTest.expect)(result.properties.fallback.anyOf[1].properties.backup).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+    });
+    (0, _extendedTest.test)("should handle allOf with attachments", async () => {
+      const schema = {
+        type: "object",
+        allOf: [{
+          type: "object",
+          properties: {
+            baseFile: {
+              type: "attachment"
+            },
+            id: {
+              type: "string"
+            }
+          }
+        }, {
+          type: "object",
+          properties: {
+            extendedFile: {
+              type: "attachment"
+            },
+            metadata: {
+              type: "object"
+            }
+          }
+        }]
+      };
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(result.allOf[0].properties.baseFile).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.allOf[1].properties.extendedFile).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.allOf[0].properties.id).toEqual({
+        type: "string"
+      });
+      (0, _extendedTest.expect)(result.allOf[1].properties.metadata).toEqual({
+        type: "object"
+      });
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+    });
+  });
+  (0, _extendedTest.describe)("Edge cases", () => {
+    (0, _extendedTest.test)("should handle schema without attachments", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          name: {
+            type: "string"
+          },
+          age: {
+            type: "integer"
+          },
+          active: {
+            type: "boolean"
+          }
+        }
+      };
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(result.properties.name).toEqual({
+        type: "string"
+      });
+      (0, _extendedTest.expect)(result.properties.age).toEqual({
+        type: "integer"
+      });
+      (0, _extendedTest.expect)(result.properties.active).toEqual({
+        type: "boolean"
+      });
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+    });
+    (0, _extendedTest.test)("should not modify original schema (immutability)", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: "attachment"
+          },
+          name: {
+            type: "string"
+          }
+        }
+      };
+      const originalSchema = JSON.parse(JSON.stringify(schema));
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(schema).toEqual(originalSchema);
+      (0, _extendedTest.expect)(schema.properties.file).toEqual({
+        type: "attachment"
+      });
+      (0, _extendedTest.expect)(schema.$defs).toBeUndefined();
+      (0, _extendedTest.expect)(result.properties.file).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+    });
+    (0, _extendedTest.test)("should handle schema with existing $defs", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: "attachment"
+          },
+          customField: {
+            $ref: "#/$defs/customType"
+          }
+        },
+        $defs: {
+          customType: {
+            type: "object",
+            properties: {
+              value: {
+                type: "string"
+              }
+            }
+          }
+        }
+      };
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(result.$defs.customType).toBeDefined();
+      (0, _extendedTest.expect)(result.$defs.customType.properties.value).toEqual({
+        type: "string"
+      });
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+      (0, _extendedTest.expect)(result.properties.file).toEqual({
+        $ref: "#/$defs/attachment"
+      });
+      (0, _extendedTest.expect)(result.properties.customField).toEqual({
+        $ref: "#/$defs/customType"
+      });
+    });
+  });
+  (0, _extendedTest.describe)("Attachment definition structure", () => {
+    (0, _extendedTest.test)("should include proper attachment definition in $defs", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: "attachment"
+          }
+        }
+      };
+      const result = (0, _validateDataUsingSchema.injectAttachmentType)(schema);
+      (0, _extendedTest.expect)(result.$defs.attachment).toBeDefined();
+      (0, _extendedTest.expect)(result.$defs.attachment.type).toBe("object");
+      const attachmentProps = result.$defs.attachment.properties;
+      (0, _extendedTest.expect)(attachmentProps).toBeDefined();
+      (0, _extendedTest.expect)(attachmentProps.fileName).toBeDefined();
+      (0, _extendedTest.expect)(attachmentProps.bucket).toBeDefined();
+      (0, _extendedTest.expect)(attachmentProps.region).toBeDefined();
+      (0, _extendedTest.expect)(attachmentProps.key).toBeDefined();
+      (0, _extendedTest.expect)(attachmentProps.suggestedFileName).toBeDefined();
+      (0, _extendedTest.expect)(result.$defs.attachment.required).toBeDefined();
+      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("fileName");
+      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("bucket");
+      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("region");
+      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("key");
+      (0, _extendedTest.expect)(result.$defs.attachment.required).toContain("suggestedFileName");
+    });
+  });
+});