@intuned/browser-dev 0.1.5-dev.1 → 0.1.6-dev.0

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

@@ -2,6 +2,7 @@
 
 var _types = require("../types");
 var _validateDataUsingSchema = require("../validateDataUsingSchema");
+var _Attachment = require("../types/Attachment");
 var _extendedTest = require("../../common/extendedTest");
 (0, _extendedTest.describe)("Data Validation Tests", () => {
   (0, _extendedTest.describe)("validate_data_using_schema function", () => {
@@ -55,7 +56,7 @@ var _extendedTest = require("../../common/extendedTest");
         });
       } catch (error) {
         (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
-        (0, _extendedTest.expect)(error.message).toContain("Data validation failed");
+        (0, _extendedTest.expect)(error.message).toContain("Validation failed");
         (0, _extendedTest.expect)(error.data).toEqual(invalidData);
       }
     });
@@ -124,7 +125,7 @@ var _extendedTest = require("../../common/extendedTest");
       } 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.message).toContain("Validation failed");
         (0, _extendedTest.expect)(error.data).toEqual(invalidData);
       }
     });
@@ -188,7 +189,7 @@ var _extendedTest = require("../../common/extendedTest");
         });
       } catch (error) {
         (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
-        (0, _extendedTest.expect)(error.message).toContain("Data validation failed");
+        (0, _extendedTest.expect)(error.message).toContain("Validation failed");
         (0, _extendedTest.expect)(error.data).toEqual(invalidData);
       }
     });
@@ -274,7 +275,7 @@ var _extendedTest = require("../../common/extendedTest");
         });
       } catch (error) {
         (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
-        (0, _extendedTest.expect)(error.message).toContain("Data validation failed");
+        (0, _extendedTest.expect)(error.message).toContain("Validation failed");
         (0, _extendedTest.expect)(error.data).toEqual(invalidData);
       }
     });
@@ -342,5 +343,1041 @@ var _extendedTest = require("../../common/extendedTest");
         schema
       })).toThrow(_types.ValidationError);
     });
+    (0, _extendedTest.test)("should validate data using schema with nullable attachment type", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: ["attachment", "null"]
+          },
+          name: {
+            type: "string"
+          }
+        },
+        required: ["file", "name"]
+      };
+      const validDataWithAttachment = {
+        file: {
+          fileName: "report.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/report.pdf",
+          suggestedFileName: "Report.pdf"
+        },
+        name: "Test With File"
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validDataWithAttachment,
+        schema
+      })).not.toThrow();
+      const validDataWithNull = {
+        file: null,
+        name: "Test Without File"
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validDataWithNull,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with nullable attachment type receiving invalid value", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: ["attachment", "null"]
+          },
+          name: {
+            type: "string"
+          }
+        },
+        required: ["file", "name"]
+      };
+      const invalidData = {
+        file: "not-an-attachment",
+        name: "Test"
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: invalidData,
+        schema
+      })).toThrow(_types.ValidationError);
+      try {
+        (0, _validateDataUsingSchema.validateDataUsingSchema)({
+          data: invalidData,
+          schema
+        });
+      } catch (error) {
+        (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
+        (0, _extendedTest.expect)(error.message).toContain("Validation failed");
+        (0, _extendedTest.expect)(error.data).toEqual(invalidData);
+      }
+    });
+    (0, _extendedTest.test)("should validate data using schema with nested empty values filtered", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          user: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string"
+              },
+              age: {
+                type: "integer"
+              },
+              email: {
+                type: "string"
+              },
+              metadata: {
+                type: "object",
+                properties: {
+                  notes: {
+                    type: "string"
+                  }
+                }
+              }
+            },
+            required: ["name", "age"]
+          },
+          items: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                title: {
+                  type: "string"
+                },
+                description: {
+                  type: "string"
+                }
+              },
+              required: ["title"]
+            }
+          }
+        },
+        required: ["user", "items"]
+      };
+      const dataWithNestedEmpty = {
+        user: {
+          name: "John Doe",
+          age: 30,
+          email: "",
+          metadata: {
+            notes: null
+          }
+        },
+        items: [{
+          title: "Item 1",
+          description: ""
+        }, {
+          title: "Item 2",
+          description: "   "
+        }]
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: dataWithNestedEmpty,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with empty values in arrays filtered", async () => {
+      const schema = {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            name: {
+              type: "string"
+            },
+            value: {
+              type: "string"
+            }
+          },
+          required: ["name"]
+        }
+      };
+      const dataWithEmptyInArray = [{
+        name: "Item 1",
+        value: ""
+      }, {
+        name: "Item 2",
+        value: null
+      }, {
+        name: "Item 3"
+      }];
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: dataWithEmptyInArray,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate that existing nullable optional fields are valid", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          name: {
+            type: "string"
+          }
+        }
+      };
+      const data = {
+        name: null
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with capital Attachment 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",
+          key: "documents/report.pdf",
+          endpoint: null,
+          suggestedFileName: "Monthly Report.pdf",
+          fileType: "document"
+        },
+        name: "Test File Upload"
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validData,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with capital Attachment comprehensive", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          requiredFile: {
+            type: "Attachment"
+          },
+          optionalFile: {
+            type: "Attachment"
+          },
+          nullableFile: {
+            type: ["Attachment", "null"]
+          },
+          filesArray: {
+            type: "array",
+            items: {
+              type: "Attachment"
+            }
+          },
+          flexibleField: {
+            type: ["Attachment", "string", "null"]
+          }
+        },
+        required: ["requiredFile", "nullableFile", "filesArray", "flexibleField"]
+      };
+      const validData = {
+        requiredFile: {
+          fileName: "required.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/required.pdf",
+          suggestedFileName: "Required.pdf"
+        },
+        nullableFile: null,
+        filesArray: [{
+          fileName: "file1.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/file1.pdf",
+          suggestedFileName: "File 1.pdf"
+        }, {
+          fileName: "file2.pdf",
+          bucket: "my-bucket",
+          region: "us-west-2",
+          key: "files/file2.pdf",
+          suggestedFileName: "File 2.pdf"
+        }],
+        flexibleField: "just a string"
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validData,
+        schema
+      })).not.toThrow();
+      const validDataWithAttachment = {
+        requiredFile: {
+          fileName: "required.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/required.pdf",
+          suggestedFileName: "Required.pdf"
+        },
+        nullableFile: {
+          fileName: "nullable.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/nullable.pdf",
+          suggestedFileName: "Nullable.pdf"
+        },
+        filesArray: [],
+        flexibleField: {
+          fileName: "flexible.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/flexible.pdf",
+          suggestedFileName: "Flexible.pdf"
+        }
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validDataWithAttachment,
+        schema
+      })).not.toThrow();
+      const validDataWithNull = {
+        requiredFile: {
+          fileName: "required.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/required.pdf",
+          suggestedFileName: "Required.pdf"
+        },
+        nullableFile: null,
+        filesArray: [],
+        flexibleField: null
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validDataWithNull,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with nested Attachment in objects", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          documents: {
+            type: "array",
+            items: {
+              type: "object",
+              properties: {
+                metadata: {
+                  type: "object",
+                  properties: {
+                    file: {
+                      type: "Attachment"
+                    },
+                    name: {
+                      type: "string"
+                    }
+                  },
+                  required: ["file", "name"]
+                }
+              },
+              required: ["metadata"]
+            }
+          }
+        },
+        required: ["documents"]
+      };
+      const validData = {
+        documents: [{
+          metadata: {
+            file: {
+              fileName: "doc1.pdf",
+              bucket: "my-bucket",
+              region: "us-east-1",
+              key: "files/doc1.pdf",
+              suggestedFileName: "Document 1.pdf"
+            },
+            name: "First Document"
+          }
+        }, {
+          metadata: {
+            file: {
+              fileName: "doc2.pdf",
+              bucket: "my-bucket",
+              region: "us-west-2",
+              key: "files/doc2.pdf",
+              suggestedFileName: "Document 2.pdf"
+            },
+            name: "Second Document"
+          }
+        }]
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validData,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with deeply nested Attachment", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          level1: {
+            type: "object",
+            properties: {
+              level2: {
+                type: "object",
+                properties: {
+                  level3: {
+                    type: "object",
+                    properties: {
+                      requiredFile: {
+                        type: "Attachment"
+                      },
+                      optionalFile: {
+                        type: "Attachment"
+                      },
+                      level4: {
+                        type: "object",
+                        properties: {
+                          deepFile: {
+                            type: "ATTACHMENT"
+                          }
+                        }
+                      }
+                    },
+                    required: ["requiredFile"]
+                  }
+                },
+                required: ["level3"]
+              }
+            },
+            required: ["level2"]
+          }
+        },
+        required: ["level1"]
+      };
+      const validData = {
+        level1: {
+          level2: {
+            level3: {
+              requiredFile: {
+                fileName: "level3.pdf",
+                bucket: "my-bucket",
+                region: "us-east-1",
+                key: "files/level3.pdf",
+                suggestedFileName: "Level 3.pdf"
+              },
+              level4: {
+                deepFile: {
+                  fileName: "level4.pdf",
+                  bucket: "my-bucket",
+                  region: "us-east-1",
+                  key: "files/level4.pdf",
+                  suggestedFileName: "Level 4.pdf"
+                }
+              }
+            }
+          }
+        }
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validData,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with Attachment in oneOf", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          content: {
+            oneOf: [{
+              type: "object",
+              properties: {
+                type: {
+                  const: "text"
+                },
+                value: {
+                  type: "string"
+                }
+              },
+              required: ["type", "value"]
+            }, {
+              type: "object",
+              properties: {
+                type: {
+                  const: "file"
+                },
+                file: {
+                  type: "Attachment"
+                }
+              },
+              required: ["type", "file"]
+            }]
+          }
+        },
+        required: ["content"]
+      };
+      const validTextData = {
+        content: {
+          type: "text",
+          value: "Some text content"
+        }
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validTextData,
+        schema
+      })).not.toThrow();
+      const validFileData = {
+        content: {
+          type: "file",
+          file: {
+            fileName: "document.pdf",
+            bucket: "my-bucket",
+            region: "us-east-1",
+            key: "files/document.pdf",
+            suggestedFileName: "Document.pdf"
+          }
+        }
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validFileData,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with Attachment in anyOf", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          resource: {
+            anyOf: [{
+              type: "string"
+            }, {
+              type: "Attachment"
+            }]
+          }
+        },
+        required: ["resource"]
+      };
+      const validStringData = {
+        resource: "https://example.com/file.pdf"
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validStringData,
+        schema
+      })).not.toThrow();
+      const validAttachmentData = {
+        resource: {
+          fileName: "file.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/file.pdf",
+          suggestedFileName: "File.pdf"
+        }
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validAttachmentData,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with Attachment array constraints", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          files: {
+            type: "array",
+            items: {
+              type: "Attachment"
+            },
+            minItems: 1,
+            maxItems: 3
+          }
+        },
+        required: ["files"]
+      };
+      const validData = {
+        files: [{
+          fileName: "file1.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/file1.pdf",
+          suggestedFileName: "File 1.pdf"
+        }, {
+          fileName: "file2.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/file2.pdf",
+          suggestedFileName: "File 2.pdf"
+        }]
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validData,
+        schema
+      })).not.toThrow();
+      const invalidDataEmpty = {
+        files: []
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: invalidDataEmpty,
+        schema
+      })).toThrow(_types.ValidationError);
+    });
+    (0, _extendedTest.test)("should validate data using schema with Attachment cross-field dependencies", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          hasAttachment: {
+            type: "boolean"
+          },
+          file: {
+            type: ["Attachment", "null"]
+          }
+        },
+        required: ["hasAttachment", "file"],
+        if: {
+          properties: {
+            hasAttachment: {
+              const: true
+            }
+          }
+        },
+        then: {
+          properties: {
+            file: {
+              type: "Attachment"
+            }
+          }
+        }
+      };
+      const validWithFile = {
+        hasAttachment: true,
+        file: {
+          fileName: "document.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/document.pdf",
+          suggestedFileName: "Document.pdf"
+        }
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validWithFile,
+        schema
+      })).not.toThrow();
+      const validWithoutFile = {
+        hasAttachment: false,
+        file: null
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validWithoutFile,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data using schema with Attachment in definitions", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          document: {
+            $ref: "#/definitions/Document"
+          }
+        },
+        required: ["document"],
+        definitions: {
+          Document: {
+            type: "object",
+            properties: {
+              title: {
+                type: "string"
+              },
+              file: {
+                type: "Attachment"
+              },
+              attachments: {
+                type: "array",
+                items: {
+                  type: "ATTACHMENT"
+                }
+              }
+            },
+            required: ["title", "file"]
+          }
+        }
+      };
+      const validData = {
+        document: {
+          title: "Important Document",
+          file: {
+            fileName: "main.pdf",
+            bucket: "my-bucket",
+            region: "us-east-1",
+            key: "files/main.pdf",
+            suggestedFileName: "Main.pdf"
+          },
+          attachments: [{
+            fileName: "attachment1.pdf",
+            bucket: "my-bucket",
+            region: "us-east-1",
+            key: "files/attachment1.pdf",
+            suggestedFileName: "Attachment 1.pdf"
+          }]
+        }
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validData,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate Attachment error messages are helpful", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          file: {
+            type: "Attachment"
+          }
+        },
+        required: ["file"]
+      };
+      const invalidData = {
+        file: {
+          fileName: "incomplete.pdf"
+        }
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: invalidData,
+        schema
+      })).toThrow(_types.ValidationError);
+      try {
+        (0, _validateDataUsingSchema.validateDataUsingSchema)({
+          data: invalidData,
+          schema
+        });
+      } catch (error) {
+        (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
+        (0, _extendedTest.expect)(error.message).toContain("Validation failed");
+        (0, _extendedTest.expect)(error.data).toEqual(invalidData);
+      }
+    });
+    (0, _extendedTest.test)("should validate data using schema with mixed casing Attachment in arrays", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          field1: {
+            type: ["Attachment", "string", "null"]
+          },
+          field2: {
+            type: ["ATTACHMENT", "number", "null"]
+          },
+          field3: {
+            type: ["attachment", "boolean", "null"]
+          },
+          field4: {
+            type: ["AtTaChMeNt", "null"]
+          }
+        },
+        required: ["field1", "field2", "field3", "field4"]
+      };
+      const validData = {
+        field1: "string value",
+        field2: 42,
+        field3: true,
+        field4: null
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validData,
+        schema
+      })).not.toThrow();
+      const validWithAttachments = {
+        field1: {
+          fileName: "file1.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/file1.pdf",
+          suggestedFileName: "File 1.pdf"
+        },
+        field2: {
+          fileName: "file2.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/file2.pdf",
+          suggestedFileName: "File 2.pdf"
+        },
+        field3: {
+          fileName: "file3.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/file3.pdf",
+          suggestedFileName: "File 3.pdf"
+        },
+        field4: {
+          fileName: "file4.pdf",
+          bucket: "my-bucket",
+          region: "us-east-1",
+          key: "files/file4.pdf",
+          suggestedFileName: "File 4.pdf"
+        }
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: validWithAttachments,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data with Attachment class instance", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          name: {
+            type: "string"
+          },
+          manufacturer: {
+            type: "string"
+          },
+          description: {
+            type: "string"
+          },
+          price: {
+            type: "number"
+          },
+          productUrl: {
+            type: "string"
+          },
+          partNumber: {
+            type: "string"
+          },
+          upc: {
+            type: "string"
+          },
+          images: {
+            type: "array"
+          },
+          attributes: {
+            type: "object"
+          },
+          features: {
+            type: "array"
+          },
+          normallyStocked: {
+            type: "boolean"
+          },
+          docs: {
+            type: "array",
+            items: {
+              type: "Attachment"
+            }
+          },
+          specSheet: {
+            type: "Attachment"
+          }
+        },
+        required: ["name", "manufacturer", "description", "price", "productUrl", "partNumber", "upc", "images", "attributes", "features", "normallyStocked"]
+      };
+      const data = {
+        name: "P-R2-B3RX",
+        manufacturer: "GracePorts®",
+        description: "PANEL INTERFACE CONNECTOR WITH RJ45; UL TYPE 4, NO OUTLET",
+        price: 176.0,
+        productUrl: "https://www.mc-mc.com/Product/graceports-p-r2-b3rx",
+        partNumber: "P-R2-B3RX",
+        upc: "842864101475",
+        images: ["https://res.cloudinary.com/mcrey/image/upload/f_auto,q_auto/w_350/v1655877314/Products/GRENPR2B3RX/IMG_50387534_GracePorts_P_R2_B3RX_1.jpg", "https://res.cloudinary.com/mcrey/image/upload/f_auto,q_auto/w_100/v1655877314/Products/GRENPR2B3RX/IMG_50387534_GracePorts_P_R2_B3RX_1.jpg", "https://res.cloudinary.com/mcrey/image/upload/f_auto,q_auto/w_100/v1655877306/Products/GRENPR2B3RX/IMG_50387535_GracePorts_P_R2_B3RX.jpg"],
+        attributes: {
+          Brand: "GracePorts®",
+          Type: "Bulkhead",
+          "Mounting Type": "Panel",
+          "Voltage Rating": "30 VDC",
+          "Connector Type": "Cat 5e Ethernet RJ45 F/F",
+          "Housing Material": "Plastic",
+          Dimensions: "3.15 in L x 1.65 in W x 1.72 in H"
+        },
+        features: ["Extension cable interfaces consist of fully shielded cable assemblies panel-mounted to the housing allowing a direct and cost effective method of interfacing to computers, printers, modems and networks", "Bulkhead interface method permits standard cable connections on both the front and the rear of the graceport unit", "Connections are made to and from the interface by way of user supplied computer cable assemblies, printed circuit assembly", "Low-profile circuit board interfaces simplify installation where backplane clearance is limited", "The compact design features a data connector on the front and terminal block connections on the rear for easy wiring", "Low voltage (data), limited to 30 VDC, high voltage supply (for computer use only)", "1 port", "6 point, NEMA 12/4, IP65, cast alloy base enclosure"],
+        normallyStocked: true,
+        docs: [new _Attachment.Attachment("123e1829-300b-4c34-9b58-19fa764c2e6b/SPEC_48757191_SpecificationSheet.pdf", "123e1829-300b-4c34-9b58-19fa764c2e6b/SPEC_48757191_SpecificationSheet.pdf", "intuned-poc", "us-west-2", "SPEC_48757191_SpecificationSheet.pdf", null, "document")],
+        specSheet: new _Attachment.Attachment("123e1829-300b-4c34-9b58-19fa764c2e6b/SPEC_48757191_SpecificationSheet.pdf", "123e1829-300b-4c34-9b58-19fa764c2e6b/SPEC_48757191_SpecificationSheet.pdf", "intuned-poc", "us-west-2", "SPEC_48757191_SpecificationSheet.pdf", null, "document")
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data with array of Attachment class instances", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          title: {
+            type: "string"
+          },
+          documents: {
+            type: "array",
+            items: {
+              type: "Attachment"
+            }
+          }
+        },
+        required: ["title", "documents"]
+      };
+      const data = {
+        title: "Project Documents",
+        documents: [new _Attachment.Attachment("doc1.pdf", "files/doc1.pdf", "my-bucket", "us-east-1", "Document 1.pdf", null, "document"), new _Attachment.Attachment("doc2.pdf", "files/doc2.pdf", "another-bucket", "us-west-2", "Document 2.pdf", "https://custom-s3.example.com", "document"), new _Attachment.Attachment("doc3.pdf", "files/doc3.pdf", "third-bucket", "eu-west-1", "Document 3.pdf")]
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should validate data with mixed Attachment instances and plain objects nested", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          project: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string"
+              },
+              sections: {
+                type: "array",
+                items: {
+                  type: "object",
+                  properties: {
+                    sectionName: {
+                      type: "string"
+                    },
+                    primaryFile: {
+                      type: "Attachment"
+                    },
+                    backupFiles: {
+                      type: "array",
+                      items: {
+                        type: "ATTACHMENT"
+                      }
+                    },
+                    metadata: {
+                      type: "object",
+                      properties: {
+                        description: {
+                          type: "string"
+                        },
+                        optionalAttachment: {
+                          type: ["attachment", "null"]
+                        }
+                      }
+                    }
+                  },
+                  required: ["sectionName", "primaryFile"]
+                }
+              }
+            },
+            required: ["name", "sections"]
+          },
+          archivedFiles: {
+            type: "array",
+            items: {
+              type: "Attachment"
+            }
+          }
+        },
+        required: ["project"]
+      };
+      const data = {
+        project: {
+          name: "Complex Project",
+          sections: [{
+            sectionName: "Introduction",
+            primaryFile: new _Attachment.Attachment("intro.pdf", "sections/intro.pdf", "project-bucket", "us-east-1", "Introduction.pdf", null, "document"),
+            backupFiles: [new _Attachment.Attachment("intro_backup1.pdf", "backups/intro_backup1.pdf", "backup-bucket", "us-west-2", "Intro Backup 1.pdf")],
+            metadata: {
+              description: "Project introduction section",
+              optionalAttachment: new _Attachment.Attachment("intro_notes.pdf", "notes/intro_notes.pdf", "notes-bucket", "us-east-1", "Intro Notes.pdf")
+            }
+          }, {
+            sectionName: "Conclusion",
+            primaryFile: new _Attachment.Attachment("conclusion.pdf", "sections/conclusion.pdf", "project-bucket", "us-east-1", "Conclusion.pdf"),
+            backupFiles: [],
+            metadata: {
+              description: "Project conclusion section",
+              optionalAttachment: null
+            }
+          }]
+        },
+        archivedFiles: [new _Attachment.Attachment("archive1.pdf", "archives/archive1.pdf", "archive-bucket", "us-east-1", "Archive 1.pdf", "https://archive.s3.example.com"), new _Attachment.Attachment("archive2.pdf", "archives/archive2.pdf", "archive-bucket", "us-east-1", "Archive 2.pdf")]
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data,
+        schema
+      })).not.toThrow();
+    });
+    (0, _extendedTest.test)("should format error messages with multiple errors correctly", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          name: {
+            type: "string"
+          },
+          age: {
+            type: "integer"
+          },
+          email: {
+            type: "string"
+          }
+        },
+        required: ["name", "age", "email"]
+      };
+      const invalidData = {
+        name: 123,
+        age: "not-a-number"
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: invalidData,
+        schema
+      })).toThrow(_types.ValidationError);
+      try {
+        (0, _validateDataUsingSchema.validateDataUsingSchema)({
+          data: invalidData,
+          schema
+        });
+      } catch (error) {
+        (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
+        const errorMessage = error.message;
+        (0, _extendedTest.expect)(errorMessage).toContain("Validation failed with");
+        (0, _extendedTest.expect)(errorMessage).toContain("error(s):");
+        const dashCount = (errorMessage.match(/-/g) || []).length;
+        const errorCount = (errorMessage.match(/error/gi) || []).length;
+        (0, _extendedTest.expect)(dashCount >= 2 || errorCount >= 2).toBe(true);
+        (0, _extendedTest.expect)(errorMessage.includes("name") || errorMessage.includes("age") || errorMessage.includes("email")).toBe(true);
+        (0, _extendedTest.expect)(error.data).toEqual(invalidData);
+      }
+    });
+    (0, _extendedTest.test)("should format error messages with nested field paths correctly", async () => {
+      const schema = {
+        type: "object",
+        properties: {
+          user: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string"
+              },
+              age: {
+                type: "integer"
+              }
+            },
+            required: ["name", "age"]
+          }
+        },
+        required: ["user"]
+      };
+      const invalidData = {
+        user: {
+          name: "John Doe"
+        }
+      };
+      (0, _extendedTest.expect)(() => (0, _validateDataUsingSchema.validateDataUsingSchema)({
+        data: invalidData,
+        schema
+      })).toThrow(_types.ValidationError);
+      try {
+        (0, _validateDataUsingSchema.validateDataUsingSchema)({
+          data: invalidData,
+          schema
+        });
+      } catch (error) {
+        (0, _extendedTest.expect)(error).toBeInstanceOf(_types.ValidationError);
+        const errorMessage = error.message;
+        (0, _extendedTest.expect)(errorMessage.includes("user") || errorMessage.includes("age")).toBe(true);
+        (0, _extendedTest.expect)(errorMessage).toContain("Validation failed with");
+        (0, _extendedTest.expect)(error.data).toEqual(invalidData);
+      }
+    });
   });
 });