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

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");
+    });
+  });
+});