@platecms/delta-validation 0.4.1 → 0.7.0

package/src/lib/test-utils/validation-result-matcher.ts

@@ -0,0 +1,71 @@
+import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { ContentValidationResultType } from "../validation-rules/base.validation-rule";
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+interface CustomMatchers<R = unknown> {
+  toBeContentValidationResult: (expected: (boolean | null)[]) => R;
+}
+
+declare module "vitest" {
+  /* eslint-disable @typescript-eslint/no-empty-interface, @typescript-eslint/no-empty-object-type */
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  interface Assertion<T = any> extends CustomMatchers<T> {}
+  interface AsymmetricMatchersContaining extends CustomMatchers {}
+  /* eslint-enable @typescript-eslint/no-empty-interface, @typescript-eslint/no-empty-object-type */
+}
+
+expect.extend({
+  toBeContentValidationResult(
+    received: ContentValidationResultType[],
+    expected: (boolean | null)[],
+  ): {
+    pass: boolean;
+    message: () => string;
+    actual?: unknown;
+    expected?: unknown;
+  } {
+    const { isNot } = this;
+
+    // eslint-disable-next-line no-unreachable-loop
+    for (let index = 0; index < received.length; index++) {
+      const result = received[index];
+      const expectedValue = expected[index];
+
+      if (expectedValue === false) {
+        if (result instanceof ValidationErrorDetails) {
+          return {
+            pass: true,
+            message: (): string =>
+              `Expected ${JSON.stringify(
+                result,
+              )}${isNot ? " not" : ""} to be an instance of ContentValidationErrorDetail. Index ${index} failed.`,
+          };
+        }
+
+        return {
+          pass: false,
+          message: (): string =>
+            `Expected ${JSON.stringify(
+              result,
+            )}${isNot ? " not" : ""} to be an instance of ContentValidationErrorDetail. Index ${index} failed.`,
+        };
+      }
+
+      if (expectedValue === result) {
+        return {
+          pass: true,
+          message: (): string =>
+            `Expected ${JSON.stringify(result)}${isNot ? " not" : ""} to be ${JSON.stringify(expectedValue)}. Index ${index} failed.`,
+        };
+      }
+
+      return {
+        pass: false,
+        message: (): string =>
+          `Expected ${JSON.stringify(received)}${isNot ? " not" : ""} to be ${JSON.stringify(expected)}`,
+      };
+    }
+
+    throw new Error("No results to compare.");
+  },
+});

package/src/lib/types/{existing-content-validation-rules-settings.type.d.ts → existing-content-validation-rules-settings.type.ts}

@@ -7,4 +7,13 @@ import { NumberBetweenValidationRuleSettings } from "../validation-rules/number-
 import { RelatableContentTypesValidationRuleSettings } from "../validation-rules/relatable-content-types.validation-rule";
 import { StringFormatValidationRuleSettings } from "../validation-rules/string-format.validation-rule";
 import { ValueTypeValidationRuleSettings } from "../validation-rules/value-type.validation-rule";
-export type ExistingContentValidationRulesSettings = AllowedValuesValidationRuleSettings | CountValidationRuleSettings | DateBetweenValidationRuleSettings | DecimalCountValidationRuleSettings | NumberBetweenValidationRuleSettings | RelatableContentTypesValidationRuleSettings<PRN> | StringFormatValidationRuleSettings | ValueTypeValidationRuleSettings;
+
+export type ExistingContentValidationRulesSettings =
+  | AllowedValuesValidationRuleSettings
+  | CountValidationRuleSettings
+  | DateBetweenValidationRuleSettings
+  | DecimalCountValidationRuleSettings
+  | NumberBetweenValidationRuleSettings
+  | RelatableContentTypesValidationRuleSettings<PRN>
+  | StringFormatValidationRuleSettings
+  | ValueTypeValidationRuleSettings;

package/src/lib/types/{existing-content-validation-rules.type.d.ts → existing-content-validation-rules.type.ts}

@@ -6,4 +6,13 @@ import { NumberBetweenValidationRule } from "../validation-rules/number-between.
 import { RelatableContentTypesValidationRule } from "../validation-rules/relatable-content-types.validation-rule";
 import { StringFormatValidationRule } from "../validation-rules/string-format.validation-rule";
 import { ValueTypeValidationRule } from "../validation-rules/value-type.validation-rule";
-export type ExistingContentValidationRules = AllowedValuesValidationRule | CountValidationRule | DateBetweenValidationRule | DecimalCountValidationRule | NumberBetweenValidationRule | RelatableContentTypesValidationRule | StringFormatValidationRule | ValueTypeValidationRule;
+
+export type ExistingContentValidationRules =
+  | AllowedValuesValidationRule
+  | CountValidationRule
+  | DateBetweenValidationRule
+  | DecimalCountValidationRule
+  | NumberBetweenValidationRule
+  | RelatableContentTypesValidationRule
+  | StringFormatValidationRule
+  | ValueTypeValidationRule;

package/src/lib/types/{existing-validation-schemas.type.d.ts → existing-validation-schemas.type.ts}

@@ -3,4 +3,10 @@ import { DateValidationSchema } from "../schemas/date.schema";
 import { ContentValueValidationSchema } from "../schemas/content-value.schema";
 import { NumberValidationSchema } from "../schemas/number.schema";
 import { StringValidationSchema } from "../schemas/string.schema";
-export type ExistingValidationSchemas = ArrayValidationSchema<unknown> | ContentValueValidationSchema | DateValidationSchema | NumberValidationSchema | StringValidationSchema;
+
+export type ExistingValidationSchemas =
+  | ArrayValidationSchema<unknown>
+  | ContentValueValidationSchema
+  | DateValidationSchema
+  | NumberValidationSchema
+  | StringValidationSchema;

package/src/lib/types/rule-instance.interface.ts

@@ -0,0 +1,9 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { RuleType } from "../enums/rule-types.enum";
+
+export interface RuleInstance<TRuleSettings> {
+  id?: string;
+  prn?: PRN;
+  settings: TRuleSettings;
+  ruleType: RuleType;
+}

package/src/lib/types/{validation-context.interface.d.ts → validation-context.interface.ts}

@@ -1,5 +1,6 @@
 import { ContentValueType } from "@platecms/delta-types";
+
 export interface ValidationContext {
-    [key: string]: ContentValueType | string[] | undefined;
-    path?: string[];
+  [key: string]: ContentValueType | string[] | undefined;
+  path?: string[];
 }

package/src/lib/types/{validation-error-data.interface.d.ts → validation-error-data.interface.ts}

@@ -1,7 +1,8 @@
 import { RuleInstance } from "./rule-instance.interface";
+
 export interface ValidationErrorData<TSettings extends object = object> {
-    path: string[];
-    message: string;
-    validationRule: RuleInstance<TSettings>;
-    provided: unknown;
+  path: string[];
+  message: string;
+  validationRule: RuleInstance<TSettings>;
+  provided: unknown;
 }

package/src/lib/types/{validation-result.interface.d.ts → validation-result.interface.ts}

@@ -1,5 +1,6 @@
 import { ValidationErrorData } from "./validation-error-data.interface";
+
 export interface ValidationResult {
-    isValid: boolean;
-    errors: ValidationErrorData[];
+  isValid: boolean;
+  errors: ValidationErrorData[];
 }

package/src/lib/types/validation-schema.interface.ts

@@ -0,0 +1,15 @@
+import { ValidationContext } from "./validation-context.interface";
+import { ValidationResult } from "./validation-result.interface";
+
+export type SchemaType = "array" | "content-value" | "date" | "number" | "string" | "union";
+
+/**
+ * TType represents the value type this schema validates.
+ * Even if validate() takes unknown, the generic links
+ * concrete schemas (e.g. StringSchema -> string, ArraySchema<TType> -> TType[])
+ * and enables type-safe composition.
+ */
+export interface ValidationSchema<TType> {
+  type: SchemaType;
+  validate(value: unknown, context?: ValidationContext): ValidationResult;
+}

package/src/lib/validation-rules/allowed-values.validation-rule.spec.ts

@@ -0,0 +1,57 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+import { AllowedValuesValidationRule } from "./allowed-values.validation-rule";
+
+describe("AllowedValuesValidationRule", () => {
+  let rulePrn: PRN;
+
+  beforeEach(() => {
+    rulePrn = PRN.fromString("prn:plate:-1:cxc:validation-rule:1");
+  });
+
+  describe("validate", () => {
+    describe("with mixed type allowed values", () => {
+      let rule: AllowedValuesValidationRule;
+
+      beforeEach(() => {
+        const allowedValues = [1, "2", true, new Date("2020-01-01"), PRN.fromString("prn:plate:-1:cxc:content-item:1")];
+        rule = new AllowedValuesValidationRule(rulePrn, { allowedValues });
+      });
+
+      it("returns an array of correct validation results", () => {
+        const result = rule.validate([
+          1,
+          "1",
+          2,
+          "2",
+          true,
+          false,
+          new Date("2020-01-01"),
+          new Date("2020-01-02"),
+          PRN.fromString("prn:plate:-1:cxc:content-item:1"),
+          PRN.fromString("prn:plate:-1:cxc:content-item:2"),
+        ]);
+        expect(result).toBeContentValidationResult([true, false, true, false, true, false, true, false, true, false]);
+      });
+    });
+
+    describe("with no allowed values", () => {
+      let rule: AllowedValuesValidationRule;
+
+      beforeEach(() => {
+        const allowedValues: ContentValueType[] = [];
+        rule = new AllowedValuesValidationRule(rulePrn, { allowedValues });
+      });
+
+      it.each([
+        ["1", false],
+        [1, false],
+        [true, false],
+        [new Date("2020-01-01"), false],
+        [PRN.fromString("prn:plate:-1:cxc:content-item:1"), false],
+      ])("returns false if the value is %s", (value, expected) => {
+        expect(rule.validate([value])).toBeContentValidationResult([expected]);
+      });
+    });
+  });
+});

package/src/lib/validation-rules/allowed-values.validation-rule.ts

@@ -0,0 +1,53 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../enums/rule-types.enum";
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { validationFunctionFromValidateValue } from "./validation-rule-function.factory";
+
+export function validateValueAllowedValues(
+  value: ContentValueType,
+  ruleInstance: RuleInstance<AllowedValuesValidationRuleSettings>,
+): ContentValidationResultType {
+  const valid = ruleInstance.settings.allowedValues.some((allowedValue) => {
+    if (value instanceof PRN) {
+      return allowedValue instanceof PRN && value.equals(allowedValue);
+    }
+
+    if (value instanceof Date) {
+      return allowedValue instanceof Date && value.getTime() === allowedValue.getTime();
+    }
+
+    return value === allowedValue;
+  });
+
+  if (!valid) {
+    return new ValidationErrorDetails(
+      // eslint-disable-next-line @typescript-eslint/no-base-to-string
+      `The provided value must be one of ${ruleInstance.settings.allowedValues.join(", ")}`,
+      ruleInstance,
+    );
+  }
+
+  return true;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const validateAllowedValues = validationFunctionFromValidateValue(validateValueAllowedValues);
+
+/**
+ * A validation rule that checks whether a value is one of the allowed values.
+ * Explicitely checks for complex values such as Dates and ContentItems
+ */
+export class AllowedValuesValidationRule extends BaseValidationRule<AllowedValuesValidationRuleSettings> {
+  public readonly ruleType: RuleType = RuleType.ALLOWED_VALUES;
+
+  public override validate(values: ContentValueType[]): ContentValidationResultType[] {
+    return validateAllowedValues(values, this);
+  }
+}
+
+export interface AllowedValuesValidationRuleSettings {
+  allowedValues: ContentValueType[];
+}

package/src/lib/validation-rules/base.validation-rule.ts

@@ -0,0 +1,35 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../enums/rule-types.enum";
+
+export type ContentValidationResultType<TRuleInstance extends RuleInstance<unknown> = RuleInstance<unknown>> =
+  | ValidationErrorDetails<TRuleInstance>
+  | true
+  | null;
+
+export abstract class BaseValidationRule<TSettings> implements RuleInstance<TSettings> {
+  public readonly prn: PRN;
+
+  public readonly settings: TSettings;
+
+  public abstract readonly ruleType: RuleType;
+
+  public constructor(prn: PRN, settings: TSettings) {
+    this.prn = prn;
+    this.settings = settings;
+  }
+
+  /**
+   * Validates ContentValue[] against the rule.
+   * Returns array with for each value: true if the value is valid, ContentValidationErrorDetail if it is invalid,
+   * and null if the rule does not apply to the value.
+   * Some validation rules perform validation on the array as a whole, in which case the array will be validated as a whole,
+   * and the result will be returned in the first element of the array. E.g. the CountValidationRule.
+   * @param values ContentValueType[] to validate
+   */
+  public validate(_: ContentValueType[]): ContentValidationResultType[] {
+    throw new Error("validate method must be overridden.");
+  }
+}

package/src/lib/validation-rules/count.validation-rule.spec.ts

@@ -0,0 +1,67 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { InvalidValidationRuleSettingsError } from "../errors/invalid-validation-rule-settings.error";
+import { CountValidationRule } from "./count.validation-rule";
+
+describe("CountValidationRule", () => {
+  const rulePrn = PRN.fromString("prn:plate:-1:cxc:validation-rule:1");
+
+  describe("constructor", () => {
+    it("throws an error if neither min nor max are provided", () => {
+      expect(() => {
+        new CountValidationRule(rulePrn, {});
+      }).toThrowError(InvalidValidationRuleSettingsError);
+    });
+  });
+
+  describe("validate", () => {
+    describe("with min and max", () => {
+      let rule: CountValidationRule;
+
+      beforeEach(() => {
+        rule = new CountValidationRule(rulePrn, { min: 1, max: 3 });
+      });
+
+      it.each([
+        [[1], true],
+        [[1, 2, 3], true],
+        [[1, 2], true],
+        [[], false],
+        [[1, 2, 3, 4], false],
+      ])("returns %s if the value count is within the bounds", (value, expected) => {
+        expect(rule.validate(value)).toBeContentValidationResult([expected]);
+      });
+    });
+
+    describe("with only min", () => {
+      let rule: CountValidationRule;
+
+      beforeEach(() => {
+        rule = new CountValidationRule(rulePrn, { min: 1 });
+      });
+
+      it.each([
+        [[1], true],
+        [[1, 2], true],
+        [[], false],
+      ])("returns %s if the value count is within the bounds", (value, expected) => {
+        expect(rule.validate(value)).toBeContentValidationResult([expected]);
+      });
+    });
+
+    describe("with only max", () => {
+      let rule: CountValidationRule;
+
+      beforeEach(() => {
+        rule = new CountValidationRule(rulePrn, { max: 3 });
+      });
+
+      it.each([
+        [[1, 2, 3], true],
+        [[1, 2], true],
+        [[1, 2, 3, 4], false],
+      ])("returns %s if the value count is within the bounds", (value, expected) => {
+        expect(rule.validate(value)).toBeContentValidationResult([expected]);
+      });
+    });
+  });
+});

package/src/lib/validation-rules/count.validation-rule.ts

@@ -0,0 +1,60 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+import { InvalidValidationRuleSettingsError } from "../errors/invalid-validation-rule-settings.error";
+import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../enums/rule-types.enum";
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+
+export function validateValuesCount<T>(
+  values: T[],
+  ruleInstance: RuleInstance<CountValidationRuleSettings>,
+): ContentValidationResultType {
+  if (ruleInstance.settings.min != null && values.length < ruleInstance.settings.min) {
+    return new ValidationErrorDetails(
+      `The amount of provided values must be greater than or equal ${ruleInstance.settings.min}.`,
+      ruleInstance,
+    );
+  }
+  if (ruleInstance.settings.max != null && values.length > ruleInstance.settings.max) {
+    return new ValidationErrorDetails(
+      `The amount of provided values must be be less than or equal ${ruleInstance.settings.max}.`,
+      ruleInstance,
+    );
+  }
+  return true;
+}
+
+/**
+ * Wrapper for validateValuesCount that wraps the result in an array to keep the same interface as the other validation functions.
+ */
+export function validateCount(
+  value: ContentValueType[],
+  ruleInstance: RuleInstance<CountValidationRuleSettings>,
+): ContentValidationResultType[] {
+  const result = validateValuesCount(value, ruleInstance);
+  return [result];
+}
+
+/**
+ * A validation rule that checks the number of values in a content field.
+ */
+export class CountValidationRule extends BaseValidationRule<CountValidationRuleSettings> {
+  public readonly ruleType: RuleType = RuleType.COUNT;
+
+  public constructor(prn: PRN, settings: CountValidationRuleSettings) {
+    if (settings.min == null && settings.max == null) {
+      throw new InvalidValidationRuleSettingsError("Either min or max must be defined.");
+    }
+    super(prn, settings);
+  }
+
+  public override validate(value: ContentValueType[]): ContentValidationResultType[] {
+    return validateCount(value, this);
+  }
+}
+
+export interface CountValidationRuleSettings {
+  min?: number;
+  max?: number;
+}

package/src/lib/validation-rules/date-between.validation-rule.spec.ts

@@ -0,0 +1,77 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { InvalidValidationRuleSettingsError } from "../errors/invalid-validation-rule-settings.error";
+import { DateBetweenValidationRule } from "./date-between.validation-rule";
+
+describe("DateBetweenValidationRule", () => {
+  const rulePrn = PRN.fromString("prn:plate:-1:cxc:validation-rule:1");
+
+  describe("constructor", () => {
+    it("throws an error if min and max are not provided", () => {
+      expect(() => {
+        new DateBetweenValidationRule(rulePrn, {});
+      }).toThrowError(InvalidValidationRuleSettingsError);
+    });
+  });
+
+  describe("validate", () => {
+    describe("with min and max", () => {
+      let rule: DateBetweenValidationRule;
+
+      beforeEach(() => {
+        rule = new DateBetweenValidationRule(rulePrn, {
+          start: new Date(2020, 1, 2, 3, 4, 5),
+          end: new Date(2020, 1, 3, 3, 4, 6),
+        });
+      });
+
+      it.each([
+        [new Date(2020, 1, 2, 3, 4, 5), true],
+        [new Date(2020, 1, 3, 3, 4, 6), true],
+        [new Date(2020, 1, 2, 3, 4, 6), true],
+        [new Date(2020, 1, 2, 3, 4, 4), false],
+        [new Date(2020, 1, 3, 3, 4, 7), false],
+        ["foo", null],
+      ])("returns %s for the value within the bounds", (value, expected) => {
+        expect(rule.validate([value])).toBeContentValidationResult([expected]);
+      });
+    });
+
+    describe("with only min", () => {
+      let rule: DateBetweenValidationRule;
+
+      beforeEach(() => {
+        rule = new DateBetweenValidationRule(rulePrn, {
+          start: new Date(2020, 1, 2, 3, 4, 5),
+        });
+      });
+
+      it.each([
+        [new Date(2020, 1, 2, 3, 4, 5), true],
+        [new Date(2020, 1, 2, 3, 4, 6), true],
+        [new Date(2020, 1, 2, 3, 4, 4), false],
+        ["foo", null],
+      ])("returns %s for the value within the bounds", (value, expected) => {
+        expect(rule.validate([value])).toBeContentValidationResult([expected]);
+      });
+    });
+
+    describe("with only max", () => {
+      let rule: DateBetweenValidationRule;
+
+      beforeEach(() => {
+        rule = new DateBetweenValidationRule(rulePrn, {
+          end: new Date(2020, 1, 3, 3, 4, 6),
+        });
+      });
+
+      it.each([
+        [new Date(2020, 1, 3, 3, 4, 6), true],
+        [new Date(2020, 1, 3, 3, 4, 5), true],
+        [new Date(2020, 1, 3, 3, 4, 7), false],
+        ["foo", null],
+      ])("returns %s for the value within the bounds", (value, expected) => {
+        expect(rule.validate([value])).toBeContentValidationResult([expected]);
+      });
+    });
+  });
+});

package/src/lib/validation-rules/date-between.validation-rule.ts

@@ -0,0 +1,54 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { ContentValueType } from "@platecms/delta-types";
+import { InvalidValidationRuleSettingsError } from "../errors/invalid-validation-rule-settings.error";
+import { ValidationErrorDetails } from "../errors/validation-error-details";
+import { RuleInstance } from "../types/rule-instance.interface";
+import { RuleType } from "../enums/rule-types.enum";
+import { BaseValidationRule, ContentValidationResultType } from "./base.validation-rule";
+import { validationFunctionFromValidateValue } from "./validation-rule-function.factory";
+
+export function validateValueDateBetween(
+  value: ContentValueType,
+  ruleInstance: RuleInstance<DateBetweenValidationRuleSettings>,
+): ContentValidationResultType {
+  if (!(value instanceof Date)) {
+    return null;
+  }
+
+  if (ruleInstance.settings.start != null && value < ruleInstance.settings.start) {
+    return new ValidationErrorDetails(
+      `The date must be greater than or equal ${ruleInstance.settings.start.toDateString()}`,
+      ruleInstance,
+    );
+  }
+  if (ruleInstance.settings.end != null && value > ruleInstance.settings.end) {
+    return new ValidationErrorDetails(
+      `The date must be lower than or equal ${ruleInstance.settings.end.toDateString()}`,
+      ruleInstance,
+    );
+  }
+  return true;
+}
+
+// eslint-disable-next-line @typescript-eslint/naming-convention
+export const validateDateBetween = validationFunctionFromValidateValue(validateValueDateBetween);
+
+export class DateBetweenValidationRule extends BaseValidationRule<DateBetweenValidationRuleSettings> {
+  public readonly ruleType: RuleType = RuleType.DATE_BETWEEN;
+
+  public constructor(prn: PRN, settings: DateBetweenValidationRuleSettings) {
+    if (settings.start == null && settings.end == null) {
+      throw new InvalidValidationRuleSettingsError("Either start or end must be defined.");
+    }
+    super(prn, settings);
+  }
+
+  public override validate(values: ContentValueType[]): ContentValidationResultType[] {
+    return validateDateBetween(values, this);
+  }
+}
+
+export interface DateBetweenValidationRuleSettings {
+  start?: Date;
+  end?: Date;
+}

package/src/lib/validation-rules/decimal-count.validation-rule.spec.ts

@@ -0,0 +1,46 @@
+import { PRN } from "@platecms/delta-plate-resource-notation";
+import { DecimalCountValidationRule } from "./decimal-count.validation-rule";
+
+describe("DecimalCountValidationRule", () => {
+  const rulePrn = PRN.fromString("prn:plate:-1:cxc:validation-rule:decimal-count");
+
+  describe("validate", () => {
+    describe("with max of 0", () => {
+      let rule: DecimalCountValidationRule;
+
+      beforeEach(() => {
+        rule = new DecimalCountValidationRule(rulePrn, {
+          max: 0,
+        });
+      });
+
+      it.each([
+        [1.0, true],
+        [1.1, false],
+        ["foo", null],
+      ])("returns %s for value with max 0", (value, expected) => {
+        expect(rule.validate([value])).toBeContentValidationResult([expected]);
+      });
+    });
+
+    describe("with max of 3", () => {
+      let rule: DecimalCountValidationRule;
+
+      beforeEach(() => {
+        rule = new DecimalCountValidationRule(rulePrn, {
+          max: 3,
+        });
+      });
+
+      it.each([
+        [1.0, true],
+        [1.23, true],
+        [1.034, true],
+        [1.0345, false],
+        ["foo", null],
+      ])("returns %s for value with max 3", (value, expected) => {
+        expect(rule.validate([value])).toBeContentValidationResult([expected]);
+      });
+    });
+  });
+});