@rosen-bridge/config 0.2.1 → 0.4.0

package/tests/config.spec.ts

@@ -40,6 +40,203 @@ describe('ConfigValidator', () => {
         testData.apiSchemaDefaultValuePairSample.defaultVal
       );
     });
+
+    /**
+     * @target generateDefault({ validate: true }) should fail when defaults violate choices
+     * @dependencies
+     * @scenario
+     * - define a primitive with choices and a wrong default
+     * - define a nested array object where a field has choices and wrong default
+     * - call generateDefault({ validate: true }) and expect failure
+     * @expected
+     * - generateDefault with validate should throw
+     */
+    it(`should fail validate=true when defaults violate choices (primitive and nested)`, async () => {
+      const cv1 = new ConfigValidator(
+        <ConfigSchema>testData.wrongChoiceDefaultSchema.schema
+      );
+      expect(() => cv1.generateDefault({ validate: true })).toThrow();
+
+      const cv2 = new ConfigValidator(
+        <ConfigSchema>testData.nestedWrongChoiceDefaultSchema.schema
+      );
+      expect(() => cv2.generateDefault({ validate: true })).toThrow();
+    });
+
+    /**
+     * @target generateDefault should return default values for array fields with
+     * string and number items
+     * @dependencies
+     * @scenario
+     * - call generateDefault on schema with array fields
+     * - check if correct default value object is returned
+     * @expected
+     * - correct default value object should have been returned including arrays
+     */
+    it(`should return default values for array fields with string and number items`, async () => {
+      const config = new ConfigValidator(
+        <ConfigSchema>testData.arraySchemaDefaultValuePairSample.schema
+      );
+      expect(config.generateDefault()).toEqual(
+        testData.arraySchemaDefaultValuePairSample.defaultVal
+      );
+    });
+
+    /**
+     * @target generateDefault should handle empty array defaults
+     * @dependencies
+     * @scenario
+     * - call generateDefault on schema with empty array default
+     * - check if empty array is included in result
+     * @expected
+     * - empty array should be included in default values
+     */
+    it(`should handle empty array defaults`, async () => {
+      const config = new ConfigValidator(
+        <ConfigSchema>testData.emptyArrayDefaultsPair.schema
+      );
+      const result = config.generateDefault();
+      expect(result).toEqual(testData.emptyArrayDefaultsPair.defaultVal);
+    });
+
+    /**
+     * @target generateDefault should exclude arrays without default values
+     * @dependencies
+     * @scenario
+     * - call generateDefault on schema with array field without default
+     * - check if array field is excluded from result
+     * @expected
+     * - array field without default should be excluded from result
+     */
+    it(`should exclude arrays without default values`, async () => {
+      const config = new ConfigValidator(
+        <ConfigSchema>testData.arrayWithoutDefaultPair.schema
+      );
+      const result = config.generateDefault();
+      expect(result).toEqual(testData.arrayWithoutDefaultPair.defaultVal);
+      expect(result).not.toHaveProperty('arrayWithoutDefault');
+    });
+
+    /**
+     * @target generateDefault should merge array of object item defaults with provided elements
+     * @dependencies
+     * @scenario
+     * - define an array of object items with item-level defaults
+     * - provide array default with elements that override some fields
+     * - call generateDefault
+     * @expected
+     * - each element is merged with object item defaults
+     */
+    it(`should merge array of object item defaults with provided elements`, async () => {
+      const config = new ConfigValidator(
+        <ConfigSchema>testData.logsArraySchemaDefaultsPair.schema
+      );
+      const result = config.generateDefault();
+      expect(result).toEqual(testData.logsArraySchemaDefaultsPair.defaultVal);
+    });
+
+    /**
+     * @target generateDefault should not validate array item defaults; validateConfig should catch it
+     * @dependencies
+     * @scenario
+     * - define an array of object items with validations (choices/required)
+     * - provide an invalid array default (e.g., wrong choice and missing required)
+     * - call generateDefault and ensure it returns merged defaults
+     * - call validateConfig and ensure it throws
+     * @expected
+     * - generateDefault should succeed and return merged values
+     * - validateConfig should throw due to schema violations in defaults
+     */
+    it(`should not validate array item defaults; validateConfig should catch it`, async () => {
+      const confValidator = new ConfigValidator(
+        <ConfigSchema>testData.invalidLogsArrayDefaultsPair.schema
+      );
+      const generated = confValidator.generateDefault();
+      expect(generated).toEqual(
+        testData.invalidLogsArrayDefaultsPair.defaultVal
+      );
+      expect(() => confValidator.validateConfig(generated)).toThrow();
+    });
+
+    /**
+     * @target generateDefault with validate option should throw for invalid defaults
+     * @dependencies
+     * @scenario
+     * - define invalid defaults (choices violation and missing required)
+     * - call generateDefault({ validate: true })
+     * @expected
+     * - generation should throw due to validation
+     */
+    it(`should throw when generateDefault is called with validate option and defaults are invalid`, async () => {
+      const confValidator = new ConfigValidator(
+        <ConfigSchema>testData.invalidDefaultsValidateOptionSchema.schema
+      );
+      expect(() => confValidator.generateDefault({ validate: true })).toThrow();
+    });
+
+    /**
+     * @target generateDefault should carry unknown keys in array item defaults; schema ignores them
+     * @dependencies
+     * @scenario
+     * - define an array of object items with known keys (path, level)
+     * - provide defaults containing an unknown key (pathsskddkfjd)
+     * - call generateDefault and ensure unknown key is preserved alongside item defaults
+     * - call validateConfig and ensure no error is thrown (unknown keys are ignored by schema)
+     * @expected
+     * - generateDefault returns merged defaults plus unknown key
+     * - validateConfig does not throw
+     */
+    it(`should reject schema defaults with unknown keys at schema validation time`, async () => {
+      expect(
+        () =>
+          new ConfigValidator(
+            <ConfigSchema>testData.unknownKeyLogsArrayDefaultsPair.schema
+          )
+      ).toThrow('key is not found in the schema');
+    });
+
+    /**
+     * @target generateDefault should handle nested array fields inside array item objects
+     * @dependencies
+     * @scenario
+     * - define an array of objects; each object has a nested array field
+     * - provide array default with and without the nested array specified
+     * - call generateDefault
+     * @expected
+     * - item-level non-array defaults are merged
+     * - nested array schema default is not merged by current implementation
+     * - nested array provided in defaults is preserved
+     */
+    it(`should handle nested array field inside array item objects`, async () => {
+      const confValidator = new ConfigValidator(
+        <ConfigSchema>testData.nestedArrayInArrayDefaultsPair.schema
+      );
+      const result = confValidator.generateDefault();
+      expect(result).toEqual(
+        testData.nestedArrayInArrayDefaultsPair.defaultVal
+      );
+    });
+
+    /**
+     * @target generateDefault should omit required fields without defaults and validation should fail
+     * @dependencies
+     * @scenario
+     * - define a required field without default
+     * - call generateDefault and ensure the field is not present
+     * - call validateConfig and ensure it throws due to missing required value
+     * @expected
+     * - defaults omit the field
+     * - validation throws
+     */
+    it(`should omit required fields without defaults and fail validation`, async () => {
+      const confValidator = new ConfigValidator(
+        <ConfigSchema>testData.requiredWithoutDefaultSchema.schema
+      );
+      const defaults = confValidator.generateDefault();
+      expect(defaults).toEqual({});
+      expect(() => confValidator.validateConfig(defaults)).toThrow();
+      expect(() => confValidator.generateDefault({ validate: true })).toThrow();
+    });
   });
 
   describe('validateSchema', () => {
@@ -54,7 +251,9 @@ describe('ConfigValidator', () => {
      * - no errors should be thrown
      */
     it(`should not throw any exceptions when a correct schema is passed`, async () => {
-      new ConfigValidator(<ConfigSchema>testData.correctApiSchema);
+      expect(() => {
+        new ConfigValidator(<ConfigSchema>testData.correctApiSchema);
+      }).not.toThrow();
     });
 
     /**
@@ -114,6 +313,126 @@ describe('ConfigValidator', () => {
           )
       ).toThrow();
     });
+
+    /**
+     * @target validateSchema should pass when array primitive defaults match items type
+     * @dependencies
+     * @scenario
+     * - construct ConfigValidator with a valid array primitive default
+     * @expected
+     * - no error thrown
+     */
+    it(`should pass when array primitive defaults match items type`, async () => {
+      expect(() => {
+        new ConfigValidator(
+          <ConfigSchema>testData.arrayPrimitiveDefaultsValid.schema
+        );
+      }).not.toThrow();
+    });
+
+    /**
+     * @target validateSchema should fail when array primitive defaults mismatch items type
+     * @dependencies
+     * @scenario
+     * - construct ConfigValidator with an invalid array primitive default
+     * @expected
+     * - error thrown
+     */
+    it(`should fail when array primitive defaults mismatch items type`, async () => {
+      expect(
+        () =>
+          new ConfigValidator(
+            <ConfigSchema>testData.arrayPrimitiveDefaultsInvalid.schema
+          )
+      ).toThrow();
+    });
+
+    /**
+     * @target validateSchema should fail when array object defaults have invalid child types
+     * @dependencies
+     * @scenario
+     * - construct ConfigValidator with an invalid array object default
+     * @expected
+     * - error thrown
+     */
+    it(`should fail when array object defaults have invalid child types`, async () => {
+      expect(
+        () =>
+          new ConfigValidator(
+            <ConfigSchema>testData.arrayObjectDefaultsInvalidChildType.schema
+          )
+      ).toThrow();
+    });
+
+    /**
+     * @target validateSchema should fail when nested array defaults have invalid element types
+     * @dependencies
+     * @scenario
+     * - construct ConfigValidator with invalid nested array defaults
+     * @expected
+     * - error thrown
+     */
+    it(`should fail when nested array defaults have invalid element types`, async () => {
+      expect(
+        () =>
+          new ConfigValidator(
+            <ConfigSchema>testData.nestedArrayDefaultsInvalid.schema
+          )
+      ).toThrow();
+    });
+
+    /**
+     * @target validateSchema should pass when nested array defaults are valid
+     * @dependencies
+     * @scenario
+     * - construct ConfigValidator with valid nested array defaults
+     * @expected
+     * - no error thrown
+     */
+    it(`should pass when nested array defaults are valid`, async () => {
+      expect(() => {
+        new ConfigValidator(
+          <ConfigSchema>testData.nestedArrayDefaultsValid.schema
+        );
+      }).not.toThrow();
+    });
+
+    /**
+     * @target validateSchema should validate nested array of objects defaults (pass)
+     * @dependencies
+     * @scenario
+     * - array of objects, with a key that is an array of objects with defaults
+     * - construct ConfigValidator and then generate defaults to ensure merge works
+     * @expected
+     * - constructor succeeds
+     * - defaults merged as expected
+     */
+    it(`should pass for nested array of objects defaults`, async () => {
+      const cv = new ConfigValidator(
+        <ConfigSchema>testData.nestedArrayOfObjectsDefaultsValid.schema
+      );
+      const defaults = cv.generateDefault();
+      expect(defaults).toEqual(
+        testData.nestedArrayOfObjectsDefaultsValid.defaultVal
+      );
+    });
+
+    /**
+     * @target validateSchema should validate nested array of objects defaults (fail)
+     * @dependencies
+     * @scenario
+     * - array of objects, inner array default has invalid element shapes
+     * @expected
+     * - constructor throws
+     */
+    it(`should fail for nested array of objects defaults with invalid inner elements`, async () => {
+      expect(
+        () =>
+          new ConfigValidator(
+            <ConfigSchema>testData.nestedArrayOfObjectsDefaultsInvalid.schema
+          )
+      ).toThrow();
+    });
   });
 
   describe('validateConfig', () => {
@@ -678,7 +997,7 @@ describe('ConfigValidator', () => {
 
     /**
      * @target validateSchema should not throw exception when "bigint" field is
-     * passed in string format
+     * passed in string format in config and default field in schema
      * @dependencies
      * @scenario
      * - call validateConfig with the config
@@ -686,15 +1005,16 @@ describe('ConfigValidator', () => {
      * @expected
      * - exception should not be thrown
      */
-    it(`should not throw exception when "bigint" field is passed in string
-    format`, async () => {
+    it(`should not throw exception when "bigint" field is passed in string format in config and default field in schema`, async () => {
       const confValidator = new ConfigValidator(
         <ConfigSchema>testData.apiSchemaConfigPairWithStringBigInt.schema
       );
 
-      confValidator.validateConfig(
-        testData.apiSchemaConfigPairWithStringBigInt.config
-      );
+      expect(() => {
+        confValidator.validateConfig(
+          testData.apiSchemaConfigPairWithStringBigInt.config
+        );
+      }).not.toThrow();
     });
 
     /**
@@ -826,6 +1146,94 @@ describe('ConfigValidator', () => {
       const types = confValidator.generateTSTypes('Infrastructure');
       expect(types).toEqual(testData.schemaTypeScriptTypesPair.types);
     });
+
+    /**
+     * @target generateTSTypes should generate unique path-based names without numeric suffixes
+     * @dependencies
+     * @scenario
+     * - define a schema with duplicate child keys under different parents
+     * - call generateTSTypes
+     * - check for path-based interface names
+     * @expected
+     * - types should include UserDatabase and ApisExplorer
+     * - types should not include numeric suffixes like Database1/Explorer1
+     */
+    it(`should generate unique path-based names without numeric suffixes`, async () => {
+      const confValidator = new ConfigValidator(
+        <ConfigSchema>testData.duplicateChildKeysSchema.schema
+      );
+      const types = confValidator.generateTSTypes('Infrastructure');
+
+      expect(types).toContain('export interface UserDatabase');
+      expect(types).toContain('export interface ApisExplorer');
+      expect(types).not.toContain('Database1');
+      expect(types).not.toContain('Explorer1');
+    });
+
+    /**
+     * @target generateTSTypes should not emit duplicate interface declarations
+     * @dependencies
+     * @scenario
+     * - define a schema with repeated key names under different parents
+     * - call generateTSTypes
+     * - count interface declarations for each name
+     * @expected
+     * - each interface name should be emitted only once
+     */
+    it(`should not emit duplicate interface declarations`, async () => {
+      const confValidator = new ConfigValidator(
+        <ConfigSchema>testData.duplicateChildKeysSchema.schema
+      );
+      const types = confValidator.generateTSTypes('Infrastructure');
+
+      const countName = (name: string) =>
+        (types.match(new RegExp(`export interface ${name}\\b`, 'g')) || [])
+          .length;
+
+      expect(countName('UserDatabase')).toBe(1);
+      expect(countName('ApisExplorer')).toBe(1);
+    });
+
+    /**
+     * @target generateTSTypes should generate distinct names for identical structures at different paths
+     * @dependencies
+     * @scenario
+     * - define identical object structures under different parents
+     * - call generateTSTypes
+     * - check that interfaces are named by path
+     * @expected
+     * - distinct names should be generated (PrimaryConnection, BackupConnection)
+     */
+    it(`should generate distinct names for identical structures at different paths`, async () => {
+      const confValidator = new ConfigValidator(
+        <ConfigSchema>testData.identicalStructurePathsSchema.schema
+      );
+      const types = confValidator.generateTSTypes('Infrastructure');
+
+      expect(types).toContain('export interface PrimaryConnection');
+      expect(types).toContain('export interface BackupConnection');
+    });
+
+    /**
+     * @target generateTSTypes should name array item object types based on path
+     * @dependencies
+     * @scenario
+     * - define an array of objects at root level
+     * - call generateTSTypes
+     * - check that array item type is generated and referenced correctly
+     * @expected
+     * - Logs array should reference Logs item interface and it should be emitted once
+     */
+    it(`should name array item object types based on path`, async () => {
+      const confValidator = new ConfigValidator(
+        <ConfigSchema>testData.arrayItemsAtRootSchema.schema
+      );
+      const types = confValidator.generateTSTypes('Infrastructure');
+
+      expect(types).toContain('export interface Logs');
+      expect((types.match(/export interface Logs\b/g) || []).length).toBe(1);
+      expect(types).toContain('logs: Logs[]');
+    });
   });
 
   describe('getConfigForLevel', () => {