perf: add more test coverage

Author: matthew2564

src/validation/ValidationExecutor.ts

@@ -185,7 +185,7 @@ export class ValidationExecutor {
       }
 
       if (!hasConstraints(error.constraints)) {
-        if (error.children.length === 0) {
+        if (error.children?.length === 0) {
           return false;
         } else {
           delete error.constraints;

test/container.spec.ts

@@ -0,0 +1,65 @@
+import { getFromContainer, useContainer } from '../src/container';
+
+describe('container', () => {
+  afterEach(() => {
+    useContainer(
+      {
+        get() {
+          return undefined;
+        },
+      },
+      { fallback: true }
+    );
+  });
+
+  it('should reuse the same default instance when fallback is enabled', () => {
+    class Service {}
+
+    useContainer(
+      {
+        get() {
+          return undefined;
+        },
+      },
+      { fallback: true }
+    );
+
+    const first = getFromContainer(Service);
+    const second = getFromContainer(Service);
+
+    expect(first).toBeInstanceOf(Service);
+    expect(first).toBe(second);
+  });
+
+  it('should fall back to the default container when fallbackOnErrors is enabled', () => {
+    class ErrorService {}
+
+    useContainer(
+      {
+        get() {
+          throw new Error('container failure');
+        },
+      },
+      { fallbackOnErrors: true }
+    );
+
+    const first = getFromContainer(ErrorService);
+    const second = getFromContainer(ErrorService);
+
+    expect(first).toBeInstanceOf(ErrorService);
+    expect(first).toBe(second);
+  });
+
+  it('should return the user container instance when one is provided', () => {
+    class ExternalService {}
+    const provided = { fromUserContainer: true };
+
+    useContainer({
+      get() {
+        return provided;
+      },
+    });
+
+    expect(getFromContainer(ExternalService)).toBe(provided);
+  });
+});

test/functional/custom-decorators.spec.ts

@@ -4,6 +4,9 @@ import { registerDecorator } from '../../src/register-decorator';
 import { ValidationOptions } from '../../src/decorator/ValidationOptions';
 import { buildMessage, ValidatorConstraint } from '../../src/decorator/decorators';
 import { ValidatorConstraintInterface } from '../../src/validation/ValidatorConstraintInterface';
+import { useContainer } from '../../src/container';
+import { getMetadataStorage, MetadataStorage } from '../../src/metadata/MetadataStorage';
+import { ConstraintMetadata } from '../../src/metadata/ConstraintMetadata';
 
 const validator = new Validator();
 
@@ -276,6 +279,17 @@ describe('decorator with symbol constraint', () => {
 });
 
 describe('inline custom decorator fast-path behavior', () => {
+  afterEach(() => {
+    useContainer(
+      {
+        get() {
+          return undefined;
+        },
+      },
+      { fallback: true }
+    );
+  });
+
   function InlineFailing(name: string, validationOptions?: ValidationOptions) {
     return function (object: object, propertyName: string): void {
       registerDecorator({
@@ -331,4 +345,58 @@ describe('inline custom decorator fast-path behavior', () => {
       expect(errors.length).toEqual(0);
     });
   });
+
+  it('should use an empty default message when inline validator does not provide one', () => {
+    class NoDefaultMessageModel {}
+
+    registerDecorator({
+      target: NoDefaultMessageModel,
+      propertyName: 'value',
+      name: 'noDefaultMessageValidator',
+      validator: {
+        validate(): boolean {
+          return false;
+        },
+      },
+    });
+
+    const metadata = getMetadataStorage()
+      .getTargetValidationMetadatas(NoDefaultMessageModel, '', false, false)
+      .find(entry => entry.propertyName === 'value');
+    const constraint = getMetadataStorage().getTargetValidatorConstraints(metadata!.constraintCls)[0];
+
+    expect(constraint.instance.defaultMessage()).toEqual('');
+    expect(metadata!.inlineDefaultMessage).toBeUndefined();
+  });
+
+  it('should throw when multiple constraint implementations are returned for a validator class', () => {
+    @ValidatorConstraint()
+    class DuplicateConstraint implements ValidatorConstraintInterface {
+      validate(): boolean {
+        return true;
+      }
+    }
+
+    const metadataStorage = new MetadataStorage();
+    metadataStorage.addConstraintMetadata(new ConstraintMetadata(DuplicateConstraint));
+    metadataStorage.addConstraintMetadata(new ConstraintMetadata(DuplicateConstraint));
+
+    useContainer({
+      get(target: Function) {
+        if (target === MetadataStorage) {
+          return metadataStorage;
+        }
+
+        return new (target as any)();
+      },
+    });
+
+    expect(() =>
+      registerDecorator({
+        target: DuplicateConstraint,
+        propertyName: 'value',
+        validator: DuplicateConstraint,
+      })
+    ).toThrow('More than one implementation of ValidatorConstraintInterface found');
+  });
 });

test/functional/metadata-storage.spec.ts

@@ -1,5 +1,7 @@
 import { MetadataStorage } from '../../src/metadata/MetadataStorage';
+import { ConstraintMetadata } from '../../src/metadata/ConstraintMetadata';
 import { ValidationMetadata } from '../../src/metadata/ValidationMetadata';
+import { ValidationSchema } from '../../src/validation-schema/ValidationSchema';
 import { ValidationTypes } from '../../src/validation/ValidationTypes';
 
 describe('MetadataStorage PR-2665 coverage', () => {
@@ -94,4 +96,175 @@ describe('MetadataStorage PR-2665 coverage', () => {
     expect(strictProperties).toContain('always');
     expect(strictProperties).not.toContain('grouped');
   });
+
+  it('should cache grouped metadata and reuse the same object for a cache key', () => {
+    const storage = new MetadataStorage();
+    const metadata = [createMetadata(ValidationTypes.CUSTOM_VALIDATION, 'prop')];
+
+    const first = storage.groupByPropertyName(metadata, 'group-cache-key');
+    const second = storage.groupByPropertyName([], 'group-cache-key');
+
+    expect(second).toBe(first);
+    expect(second.prop).toHaveLength(1);
+  });
+
+  it('should append constraint metadata for the same target', () => {
+    class TestConstraint {}
+
+    const storage = new MetadataStorage();
+    storage.addConstraintMetadata(new ConstraintMetadata(TestConstraint, 'first'));
+    storage.addConstraintMetadata(new ConstraintMetadata(TestConstraint, 'second'));
+
+    expect(storage.getTargetValidatorConstraints(TestConstraint)).toHaveLength(2);
+  });
+
+  it('should cache target metadata results and include inherited grouped metadata', () => {
+    class ParentTarget {}
+    class ChildTarget extends ParentTarget {}
+
+    const storage = new MetadataStorage();
+    const inheritedGrouped = new ValidationMetadata({
+      type: ValidationTypes.CUSTOM_VALIDATION,
+      target: ParentTarget,
+      propertyName: 'inheritedGrouped',
+    });
+    inheritedGrouped.groups = ['g1'];
+
+    storage.addValidationMetadata(inheritedGrouped);
+
+    const cacheKey = storage.buildCacheKey(ChildTarget, '', false, false, ['g1']);
+    const first = storage.getTargetValidationMetadatas(ChildTarget, '', false, false, ['g1'], cacheKey);
+    const second = storage.getTargetValidationMetadatas(ChildTarget, '', false, false, ['g1'], cacheKey);
+
+    expect(second).toBe(first);
+    expect(first.map(metadata => metadata.propertyName)).toContain('inheritedGrouped');
+  });
+
+  it('should ignore inherited metadata whose target is not actually in the prototype chain', () => {
+    class ParentTarget {}
+    class ChildTarget extends ParentTarget {}
+    class RogueTarget {}
+
+    const storage = new MetadataStorage();
+    const rogueMetadata = new ValidationMetadata({
+      type: ValidationTypes.CUSTOM_VALIDATION,
+      target: RogueTarget,
+      propertyName: 'rogue',
+    });
+
+    (storage as any).validationMetadatas = new Map([[ParentTarget, [rogueMetadata]]]);
+
+    expect(storage.getTargetValidationMetadatas(ChildTarget, '', false, false)).toEqual([]);
+  });
+
+  it('should transform validation schemas into metadata entries', () => {
+    const storage = new MetadataStorage();
+    const schema: ValidationSchema = {
+      name: 'SchemaTarget',
+      properties: {
+        field: [
+          {
+            type: ValidationTypes.CUSTOM_VALIDATION,
+            name: 'schemaConstraint',
+            constraints: ['x'],
+            message: 'schema message',
+          },
+        ],
+      },
+    };
+
+    storage.addValidationSchema(schema);
+
+    const metadatas = (storage as any).validationMetadatas.get('SchemaTarget');
+    expect(metadatas).toHaveLength(1);
+    expect(metadatas[0].name).toEqual('schemaConstraint');
+    expect(metadatas[0].propertyName).toEqual('field');
+  });
+
+  it('should ignore original metadata entries whose target does not match the constructor or schema', () => {
+    class ActualTarget {}
+    class OtherTarget {}
+
+    const storage = new MetadataStorage();
+    const mismatched = new ValidationMetadata({
+      type: ValidationTypes.CUSTOM_VALIDATION,
+      target: OtherTarget,
+      propertyName: 'mismatch',
+    });
+
+    (storage as any).validationMetadatas = new Map([[ActualTarget, [mismatched]]]);
+
+    expect(storage.getTargetValidationMetadatas(ActualTarget, '', false, false)).toEqual([]);
+  });
+
+  it('should exclude string and self-targeted inherited metadata', () => {
+    class ParentTarget {}
+    class ChildTarget extends ParentTarget {}
+
+    const storage = new MetadataStorage();
+    const schemaInherited = new ValidationMetadata({
+      type: ValidationTypes.CUSTOM_VALIDATION,
+      target: 'SchemaTarget',
+      propertyName: 'schemaInherited',
+    });
+    const selfInherited = new ValidationMetadata({
+      type: ValidationTypes.CUSTOM_VALIDATION,
+      target: ChildTarget,
+      propertyName: 'selfInherited',
+    });
+    const validInherited = new ValidationMetadata({
+      type: ValidationTypes.CUSTOM_VALIDATION,
+      target: ParentTarget,
+      propertyName: 'validInherited',
+    });
+    validInherited.always = true;
+
+    (storage as any).validationMetadatas = new Map([[ParentTarget, [schemaInherited, selfInherited, validInherited]]]);
+
+    const metadatas = storage.getTargetValidationMetadatas(ChildTarget, '', false, true);
+
+    expect(metadatas.map(metadata => metadata.propertyName)).toEqual(['validInherited']);
+  });
+
+  it('should prefer original metadata over inherited metadata with the same property and type', () => {
+    class ParentTarget {}
+    class ChildTarget extends ParentTarget {}
+
+    const storage = new MetadataStorage();
+    const original = new ValidationMetadata({
+      type: ValidationTypes.CUSTOM_VALIDATION,
+      target: ChildTarget,
+      propertyName: 'shared',
+    });
+    const inheritedDuplicate = new ValidationMetadata({
+      type: ValidationTypes.CUSTOM_VALIDATION,
+      target: ParentTarget,
+      propertyName: 'shared',
+    });
+
+    storage.addValidationMetadata(original);
+    storage.addValidationMetadata(inheritedDuplicate);
+
+    const metadatas = storage.getTargetValidationMetadatas(ChildTarget, '', false, false);
+
+    expect(metadatas).toHaveLength(1);
+    expect(metadatas[0]).toBe(original);
+  });
+
+  it('should exclude inherited grouped metadata when strictGroups is enabled without groups', () => {
+    class ParentTarget {}
+    class ChildTarget extends ParentTarget {}
+
+    const storage = new MetadataStorage();
+    const inheritedGrouped = new ValidationMetadata({
+      type: ValidationTypes.CUSTOM_VALIDATION,
+      target: ParentTarget,
+      propertyName: 'inheritedGrouped',
+    });
+    inheritedGrouped.groups = ['g1'];
+
+    storage.addValidationMetadata(inheritedGrouped);
+
+    expect(storage.getTargetValidationMetadatas(ChildTarget, '', false, true)).toEqual([]);
+  });
 });