@invariant--labs/foundation 1.1.2 → 1.1.5

package/src/testing/stubs/stub.ts

@@ -1,170 +0,0 @@
-import { FakeImplementationError } from "../../core/errors";
-import { hashKey } from "../../utils";
-
-/** Extracts method names from a type as string literal union */
-type MethodKeys<T> = { [K in keyof T]: T[K] extends (...args: never[]) => unknown ? K : never }[keyof T] & string;
-
-/** Extracts the argument types of a method */
-type MethodArgs<T, K extends keyof T> = T[K] extends (...args: infer P) => unknown ? P : never;
-
-/** Extracts the awaited return value of a method (unwraps Promise) */
-type MethodReturn<T, K extends keyof T> = T[K] extends (...args: never[]) => infer R ? Awaited<R> : never;
-
-/** Extracts the raw return type of a method (preserves Promise) */
-type MethodReturnType<T, K extends keyof T> = T[K] extends (...args: never[]) => infer R ? R : never;
-
-type StubEntry<TResult> = { type: "result"; value: TResult } | { type: "error"; error: Error };
-type StubStore<TSelf> = Map<string, StubEntry<MethodReturn<TSelf, MethodKeys<TSelf>>>>;
-
-/**
- * Factory for generating stub keys.
- * Centralizes the logic for global (method-level) and specific (args-level) keys.
- */
-class StubKeyFactory<TSelf, K extends MethodKeys<TSelf>> {
-  constructor(
-    private readonly methodName: K,
-    private readonly args?: MethodArgs<TSelf, K>,
-  ) {}
-
-  /** Global key for method-level stubs (applies to any args) */
-  global(): string {
-    return this.methodName;
-  }
-
-  /** Specific key for arg-specific stubs */
-  specific(): string {
-    return hashKey({ methodName: this.methodName, params: this.args });
-  }
-}
-
-/**
- * Builder for specifying method arguments or global method behavior.
- * Part of the fluent API: `stub.onMethod("name").withArgs(...)` or `stub.onMethod("name").throwError(...)`
- */
-class StubArgsBuilder<TSelf, K extends MethodKeys<TSelf>> {
-  private readonly keyFactory: StubKeyFactory<TSelf, K>;
-
-  constructor(
-    private readonly store: StubStore<TSelf>,
-    private readonly methodName: K,
-    private readonly className: string,
-  ) {
-    this.keyFactory = new StubKeyFactory(methodName);
-  }
-
-  /**
-   * Specifies the arguments for the stubbed method call.
-   * @param args - The arguments to match when the method is called
-   */
-  withArgs(...args: MethodArgs<TSelf, K>): StubResultBuilder<TSelf, K> {
-    return new StubResultBuilder(this.store, this.methodName, args, this.className);
-  }
-
-  /**
-   * Stubs the method to return a value for any arguments.
-   * @param result - The value to return regardless of arguments
-   */
-  returnValue(result: MethodReturn<TSelf, K>): void {
-    this.store.set(this.keyFactory.global(), { type: "result", value: result });
-  }
-
-  /**
-   * Stubs the method to throw an error for any arguments.
-   * @param error - The error to throw regardless of arguments
-   */
-  throwError(error: Error): void {
-    this.store.set(this.keyFactory.global(), { type: "error", error });
-  }
-}
-
-/**
- * Builder for defining stub behavior or executing the stub.
- * Part of the fluent API: `stub.onMethod("name").withArgs(...).returnValue(...)`
- */
-class StubResultBuilder<TSelf, K extends MethodKeys<TSelf>> {
-  private readonly keyFactory: StubKeyFactory<TSelf, K>;
-
-  constructor(
-    private readonly store: StubStore<TSelf>,
-    methodName: K,
-    args: MethodArgs<TSelf, K>,
-    private readonly className: string,
-  ) {
-    this.keyFactory = new StubKeyFactory(methodName, args);
-  }
-
-  /**
-   * Stubs the method to return a value when called with the specified arguments.
-   * @param result - The value to return
-   */
-  returnValue(result: MethodReturn<TSelf, K>): void {
-    this.store.set(this.keyFactory.specific(), { type: "result", value: result });
-  }
-
-  /**
-   * Stubs the method to throw an error when called with the specified arguments.
-   * @param error - The error to throw
-   */
-  throwError(error: Error): void {
-    this.store.set(this.keyFactory.specific(), { type: "error", error });
-  }
-
-  /**
-   * Executes the stub and returns the configured result or throws the configured error.
-   * @throws {FakeImplementationError} If no stub is configured for the given method and arguments
-   * @throws The configured error if `throwError` was used (with or without args)
-   */
-  execute(): MethodReturnType<TSelf, K> {
-    const entry = this.store.get(this.keyFactory.specific()) ?? this.store.get(this.keyFactory.global());
-
-    if (!entry) {
-      throw new FakeImplementationError(this.className, this.keyFactory.global());
-    }
-
-    if (entry.type === "error") {
-      throw entry.error;
-    }
-
-    return entry.value as MethodReturnType<TSelf, K>;
-  }
-}
-
-/**
- * Abstract base class for creating type-safe method stubs.
- *
- * @example
- * ```typescript
- * class FakeUserService extends Stub<FakeUserService> implements UserService {
- *   async fetchUser(id: string): Promise<User> {
- *     return this.onMethod("fetchUser").withArgs(id).execute();
- *   }
- * }
- *
- * // In tests:
- * const fake = new FakeUserService();
- *
- * // Stub specific args
- * fake.onMethod("fetchUser").withArgs("123").returnValue({ id: "123", name: "John" });
- * fake.onMethod("fetchUser").withArgs("invalid").throwError(new NotFoundError());
- *
- * // Stub for any args (global fallback)
- * fake.onMethod("fetchUser").returnValue({ id: "default", name: "Default" });
- * fake.onMethod("fetchUser").throwError(new ServiceUnavailableError());
- * ```
- */
-export abstract class Stub<TSelf = unknown> {
-  protected store: StubStore<TSelf> = new Map();
-
-  /**
-   * Starts the stub configuration for a method.
-   * @param methodName - The name of the method to stub
-   */
-  onMethod<K extends MethodKeys<TSelf>>(methodName: K): StubArgsBuilder<TSelf, K> {
-    return new StubArgsBuilder(this.store, methodName, this.constructor.name);
-  }
-
-  /** Clears all stubbed configurations. */
-  clear(): void {
-    this.store.clear();
-  }
-}

package/src/utils/array.spec.ts

@@ -1,29 +0,0 @@
-import { chunk } from "./array";
-
-const generateArray = (length: number): number[] => new Array<number>(length).fill(0);
-
-describe("chunk", () => {
-  it("should split 1 array 100 items into 10 array 10 items", () => {
-    const ARRAY = generateArray(100);
-
-    const chunks = chunk(ARRAY, 10);
-
-    expect(chunks.length).toEqual(10);
-    chunks.forEach((chunk) => expect(chunk.length).toEqual(10));
-  });
-
-  it("should split 1 array 95 items into 9 array 10 items and 1 array 5 items", () => {
-    const ARRAY = generateArray(95);
-
-    const chunks = chunk(ARRAY, 10);
-
-    expect(chunks.length).toEqual(10);
-    chunks.forEach((chunk, index) => {
-      if (index !== 9) {
-        expect(chunk.length).toEqual(10);
-      } else {
-        expect(chunk.length).toEqual(5);
-      }
-    });
-  });
-});

package/src/utils/array.ts

@@ -1,10 +0,0 @@
-/* eslint-disable @typescript-eslint/unbound-method */
-import _ from "lodash";
-
-export const uniqBy = _.uniqBy;
-export const maxBy = _.maxBy;
-export const minBy = _.minBy;
-export const chunk = _.chunk;
-export const shuffle = _.shuffle;
-export const sum = _.sum;
-export const sortBy = _.sortBy;

package/src/utils/base64.spec.ts

@@ -1,18 +0,0 @@
-import { base64ToString, stringToBase64 } from "./base64";
-
-const UNICODE_STRING = "foo © bar 𝌆 baz";
-const ENCODED_BASE64 = "Zm9vIMKpIGJhciDwnYyGIGJheg==";
-
-describe("base64", () => {
-  describe("base64ToString", () => {
-    it("should decoded base64 to string", () => {
-      expect(base64ToString(ENCODED_BASE64)).toEqual(UNICODE_STRING);
-    });
-  });
-
-  describe("stringToBase64", () => {
-    it("should encoded string to base64", () => {
-      expect(stringToBase64(UNICODE_STRING)).toEqual(ENCODED_BASE64);
-    });
-  });
-});

package/src/utils/base64.ts

@@ -1,6 +0,0 @@
-import { decode as decodeBase64, encode as encodeBase64 } from "base-64";
-import { decode as decodeUtf8, encode as encodeUtf8 } from "utf8";
-
-export const stringToBase64 = (str: string) => encodeBase64(encodeUtf8(str));
-
-export const base64ToString = (base64: string) => decodeUtf8(decodeBase64(base64));

package/src/utils/collection.ts

@@ -1,4 +0,0 @@
-import _ from "lodash";
-
-export const groupBy = (...args: Parameters<typeof _.groupBy>) => _.groupBy(...args);
-export const uniq = <T>(args: T[]) => _.uniq<T>(args);

package/src/utils/common.ts

@@ -1,13 +0,0 @@
-export type RecursiveKeyOf<TObj extends object> = {
-  [TKey in keyof TObj & (string | number)]: RecursiveKeyOfHandleValue<TObj[TKey], `${TKey}`>;
-}[keyof TObj & (string | number)];
-
-type RecursiveKeyOfInner<TObj extends object> = {
-  [TKey in keyof TObj & (string | number)]: RecursiveKeyOfHandleValue<TObj[TKey], `['${TKey}']` | `.${TKey}`>;
-}[keyof TObj & (string | number)];
-
-type RecursiveKeyOfHandleValue<TValue, Text extends string> = TValue extends unknown[]
-  ? Text
-  : TValue extends object
-    ? Text | `${Text}${RecursiveKeyOfInner<TValue>}`
-    : Text;

package/src/utils/csv.ts

@@ -1,49 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-import "reflect-metadata";
-import { Transform } from "stream";
-
-const META_KEY = Symbol("csv:columns");
-
-type ColumnMeta = { propertyKey: string; displayName: string };
-
-export function CSVFileRecord(): ClassDecorator {
-  return function (target: object) {
-    Reflect.defineMetadata(META_KEY, [], target);
-  };
-}
-
-export function Column(displayName: string): PropertyDecorator {
-  return function (target: object, propertyKey: string | symbol) {
-    const columns: ColumnMeta[] = Reflect.getMetadata(META_KEY, target) ?? [];
-    columns.push({ propertyKey: propertyKey as string, displayName });
-    Reflect.defineMetadata(META_KEY, columns, target);
-  };
-}
-
-export class CSVStream extends Transform {
-  private headerWritten = false;
-
-  constructor() {
-    super({ objectMode: true });
-  }
-
-  _transform(data: Record<string, string>, _enc: string, done: () => void) {
-    const columns = Reflect.getMetadata(META_KEY, data) as ColumnMeta[] | undefined;
-    if (!columns) {throw new Error("data is not a valid record");}
-
-    if (!this.headerWritten) {
-      this.push(columns.map((c) => c.displayName).join(",") + "\r\n");
-      this.headerWritten = true;
-    }
-
-    const row = columns.map((c) => (data[c.propertyKey] ?? "").toString().replace(/"/g, '""'));
-    this.push(`"${row.join('","')}"\r\n`);
-
-    done();
-  }
-
-  _flush(done: () => void) {
-    this.headerWritten = false;
-    done();
-  }
-}

package/src/utils/date/date-range.ts

@@ -1,4 +0,0 @@
-export interface DateRange {
-  from?: Date;
-  to?: Date;
-}

package/src/utils/date/date.spec.ts

@@ -1,100 +0,0 @@
-import { arrayContainsDate, compareDates, composeDate, daysBetweenDates, isValidDate, makeDateRange } from "./date";
-
-describe("makeDateRange", () => {
-  it("should include from and to", () => {
-    const from = new Date("2021-07-13");
-    const to = new Date("2021-07-15");
-
-    expect(makeDateRange(from, to)).toEqual([new Date("2021-07-13"), new Date("2021-07-14"), new Date("2021-07-15")]);
-  });
-
-  it("should not make a range if to is before from", () => {
-    const from = new Date("2021-07-29");
-    const to = new Date("2021-07-28");
-
-    expect(makeDateRange(from, to)).toEqual([]);
-  });
-});
-
-describe("compareDates", () => {
-  it("should make correct comparisons", () => {
-    expect(compareDates(new Date("2021-06-15"), new Date("2021-06-17"))).toBeLessThan(0);
-    expect(compareDates(new Date("2021-06-15"), new Date("2021-06-13"))).toBeGreaterThan(0);
-    expect(compareDates(new Date("2021-06-15"), new Date("2021-06-15"))).toBe(0);
-  });
-
-  it("should order an array of dates ASC", () => {
-    const array = [new Date("2021-06-17"), new Date("2021-06-13"), new Date("2021-06-19"), new Date("2021-06-15")];
-
-    expect(array.sort(compareDates)).toEqual([
-      new Date("2021-06-13"),
-      new Date("2021-06-15"),
-      new Date("2021-06-17"),
-      new Date("2021-06-19"),
-    ]);
-  });
-});
-
-describe("arrayContainsDate", () => {
-  it("should find a date in an array of dates", () => {
-    const date = new Date("2021-06-15");
-    const array = [new Date("2021-06-13"), new Date("2021-06-15"), new Date("2021-06-17")];
-
-    expect(arrayContainsDate(array, date)).toBe(true);
-  });
-
-  it("should not find a date if no date is the same", () => {
-    const date = new Date("2021-06-15");
-    const array = [new Date("2021-06-13"), new Date("2021-06-15T22:00:00"), new Date("2021-06-17")];
-
-    expect(arrayContainsDate(array, date)).toBe(false);
-  });
-});
-
-describe("daysBetween dates", () => {
-  it("sould compute the number of days between dates", () => {
-    const date1 = new Date("2021-06-15");
-    const date2 = new Date("2021-06-11");
-
-    expect(daysBetweenDates(date1, date2)).toBe(4);
-  });
-
-  it("should floor the result of the computation", () => {
-    const date1 = new Date("2021-06-15T12:00:00.000Z");
-    const date2 = new Date("2021-06-11");
-
-    expect(daysBetweenDates(date1, date2)).toBe(4);
-  });
-});
-
-describe("composeDate", () => {
-  describe("should compose a date from a string and a timezone", () => {
-    it("Asia/Ho_Chi_Minh", () => {
-      const dateStr = "2021-06-15 12:00:00";
-      const format = "YYYY-MM-DD HH:mm:ss";
-      const timezone = "Asia/Ho_Chi_Minh"; // UTC+7
-
-      expect(composeDate(dateStr, format, timezone)).toEqual(new Date("2021-06-15T05:00:00.000Z"));
-    });
-
-    it("UTC", () => {
-      const dateStr = "15/06/2021 12:00";
-      const format = "DD/MM/YYYY HH:mm";
-      const timezone = "UTC";
-
-      expect(composeDate(dateStr, format, timezone)).toEqual(new Date("2021-06-15T12:00:00.000Z"));
-    });
-  });
-});
-
-describe("isValidDate", () => {
-  it("should return true if the date is valid", () => {
-    const date = new Date("2021-06-15");
-    expect(isValidDate(date)).toBe(true);
-  });
-
-  it("should return false if the date is invalid", () => {
-    const date = new Date("invalid");
-    expect(isValidDate(date)).toBe(false);
-  });
-});

package/src/utils/date/date.ts

@@ -1,177 +0,0 @@
-import dayjs, { extend } from "dayjs";
-import customParseFormat from "dayjs/plugin/customParseFormat";
-import quarterPlugin from "dayjs/plugin/quarterOfYear";
-import relativeTime from "dayjs/plugin/relativeTime";
-import timezone from "dayjs/plugin/timezone";
-import utc from "dayjs/plugin/utc";
-
-import { maxBy, minBy } from "../array";
-import { RecursiveKeyOf } from "../common";
-import { get } from "../object";
-import { DateRange } from "./date-range";
-
-extend(quarterPlugin);
-extend(timezone);
-extend(utc);
-extend(relativeTime);
-extend(customParseFormat);
-
-export const makeDateRange = (from: Date, to: Date) => {
-  const range: Date[] = [];
-
-  for (let current = new Date(from); current <= to; current.setDate(current.getDate() + 1)) {
-    range.push(new Date(current));
-  }
-
-  return range;
-};
-
-const MS_IN_DAY = 86_400_000;
-
-export const daysBetweenDates = (date1: Date, date2: Date): number =>
-  Math.floor(Math.abs(date2.getTime() - date1.getTime()) / MS_IN_DAY);
-
-export const compareDates = (date1: Date, date2: Date): number => date1.getTime() - date2.getTime();
-
-export const arrayContainsDate = (dateArray: Date[], date: Date): boolean =>
-  dateArray.some((d) => compareDates(date, d) === 0);
-
-export const isSame = (date: Date, compareDate: Date, type?: dayjs.QUnitType): boolean =>
-  dayjs(date).isSame(compareDate, type);
-
-export const isSameOrBefore = (date: Date, compareDate: Date): boolean =>
-  date.getTime() <= compareDate.getTime();
-
-export const isBefore = (date: Date, compareDate: Date): boolean =>
-  date.getTime() < compareDate.getTime();
-
-export const isSameOrAfter = (date: Date, compareDate: Date): boolean =>
-  date.getTime() >= compareDate.getTime();
-
-export const isAfter = (date: Date, compareDate: Date): boolean =>
-  date.getTime() > compareDate.getTime();
-
-export const diffDay = (date: Date, compareDate: Date): number =>
-  Math.ceil((compareDate.getTime() - date.getTime()) / MS_IN_DAY);
-
-export const diffYear = (date1: Date, date2: Date) =>
-  dayjs(date1).diff(date2, "year", true);
-
-export const diff = (date: Date, compareDate: Date, unit?: dayjs.QUnitType | dayjs.OpUnitType, float?: boolean) =>
-  dayjs(date).diff(compareDate, unit, float);
-
-export type GroupUnit = "day" | "month" | "quarter" | "year";
-
-export type GroupDate<T> = {
-  beginOfUnit: Date;
-  endOfUnit: Date;
-  values: T[];
-  unit: GroupUnit;
-};
-
-const makeGroupKey = (date: Date, unit: GroupUnit): string => {
-  const y = date.getFullYear();
-  const m = date.getMonth();
-  switch (unit) {
-    case "day": return `${y}-${m}-${date.getDate()}`;
-    case "month": return `${y}-${m}-m`;
-    case "quarter": return `${y}-${Math.floor(m / 3)}-q`;
-    case "year": return `${y}`;
-  }
-};
-
-export function groupBy<T extends object>(array: T[], key: RecursiveKeyOf<T>, unit: GroupUnit): GroupDate<T>[] {
-  const groups: Map<string, GroupDate<T>> = new Map();
-
-  array.forEach((item) => {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-    const date = get(item, key);
-    if (!(date instanceof Date)) {
-      return;
-    }
-
-    const groupKey = makeGroupKey(date, unit);
-
-    const group = groups.get(groupKey) || {
-      beginOfUnit: dayjs(date).startOf(unit).toDate(),
-      endOfUnit: dayjs(date).endOf(unit).toDate(),
-      values: [],
-      unit,
-    };
-
-    group.values.push(item);
-    groups.set(groupKey, group);
-  });
-
-  return Array.from(groups.values());
-}
-
-export function fillMissingRangeValues<T extends object>(
-  array: GroupDate<T>[],
-  unit: GroupUnit,
-  dateRange?: DateRange,
-): GroupDate<T>[] {
-  const groups: Map<string, GroupDate<T>> = new Map(
-    array.map((item) => {
-      return [makeGroupKey(item.beginOfUnit, unit), item];
-    }),
-  );
-
-  const minDate = dateRange?.from
-    ? dayjs(dateRange.from).startOf(unit).toDate()
-    : dayjs(minBy(array, "beginOfUnit")?.beginOfUnit).startOf(unit).toDate();
-
-  const maxDate = dateRange?.to
-    ? dayjs(dateRange.to).endOf(unit).toDate()
-    : dayjs(maxBy(array, "beginOfUnit")?.beginOfUnit).endOf(unit).toDate();
-
-  for (let date = new Date(minDate); isSameOrBefore(date, maxDate); date = add(date, 1, unit)) {
-    const groupKey = makeGroupKey(date, unit);
-    const group = groups.get(groupKey) || {
-      beginOfUnit: dayjs(date).startOf(unit).toDate(),
-      endOfUnit: dayjs(date).endOf(unit).toDate(),
-      values: [],
-      unit,
-    };
-    groups.set(groupKey, group);
-  }
-
-  return Array.from(groups.values());
-}
-
-type DateUnit = "quarter" | "year" | "month" | "day";
-type TimeUnit = DateUnit | "hour" | "minute" | "second" | "millisecond";
-
-export const startOf = (date: Date, unit: DateUnit) => dayjs(date).startOf(unit).toDate();
-
-export const endOf = (date: Date, unit: DateUnit) => dayjs(date).endOf(unit).toDate();
-
-export const subtract = (date: Date, n: number, unit: TimeUnit) => dayjs(date).subtract(n, unit).toDate();
-
-export const add = (date: Date, n: number, unit: TimeUnit) => dayjs(date).add(n, unit).toDate();
-
-export const getQuarter = (date: Date) => dayjs(date).quarter();
-
-export const randomDate = (start: Date, end: Date) =>
-  new Date(start.getTime() + Math.random() * (end.getTime() - start.getTime()));
-
-export const format = (date: Date, fmt: string, timezone?: string) => {
-  const d = dayjs(date);
-  if (!d.isValid()) {return "";}
-
-  if (timezone) {
-    try { return d.tz(timezone).format(fmt); } catch { /* fall through */ }
-  }
-
-  return d.format(fmt);
-};
-
-export const toNow = (date: Date) => dayjs(date).toNow();
-
-export const fromNow = (date: Date) => dayjs(date).fromNow();
-
-export const composeDate = (dateStr: string, fmt: string, timezone: string) => {
-  try { return dayjs.tz(dateStr, fmt, timezone).toDate(); } catch { return new Date(dateStr); }
-};
-
-export const isValidDate = (date: Date) => dayjs(date).isValid();

package/src/utils/date/diff.spec.ts

@@ -1,66 +0,0 @@
-import { add, diff } from "./date";
-
-const NOW = Date.now();
-
-const ONE_MS = 1;
-const ONE_SECOND = ONE_MS * 1000;
-const ONE_MINUTE = ONE_SECOND * 60;
-const ONE_HOUR = ONE_MINUTE * 60;
-
-describe("diff", () => {
-  describe("millisecond", () => {
-    it("should return diff millisecond", () => {
-      const result = diff(new Date(NOW + ONE_MS), new Date(NOW), "millisecond");
-
-      expect(result).toEqual(1);
-    });
-  });
-
-  describe("second", () => {
-    it("should return diff second", () => {
-      const result = diff(new Date(NOW + ONE_SECOND), new Date(NOW), "second");
-
-      expect(result).toEqual(1);
-    });
-  });
-
-  describe("minute", () => {
-    it("should return diff minute", () => {
-      const result = diff(new Date(NOW + ONE_MINUTE), new Date(NOW), "minute");
-
-      expect(result).toEqual(1);
-    });
-  });
-
-  describe("hour", () => {
-    it("should return diff hour", () => {
-      const result = diff(new Date(NOW + ONE_HOUR), new Date(NOW), "hour");
-
-      expect(result).toEqual(1);
-    });
-  });
-
-  describe("day", () => {
-    it("should return diff day", () => {
-      const result = diff(add(new Date(NOW), 1, "day"), new Date(NOW), "day");
-
-      expect(result).toEqual(1);
-    });
-  });
-
-  describe("month", () => {
-    it("should return diff month", () => {
-      const result = diff(add(new Date(NOW), 1, "month"), new Date(NOW), "month");
-
-      expect(result).toEqual(1);
-    });
-  });
-
-  describe("year", () => {
-    it("should return diff year", () => {
-      const result = diff(add(new Date(NOW), 1, "year"), new Date(NOW), "year");
-
-      expect(result).toEqual(1);
-    });
-  });
-});

package/src/utils/date/diffYear.spec.ts

@@ -1,23 +0,0 @@
-import { diffYear } from "./date";
-
-describe("diffYear", () => {
-  it("should return correct value if firstDate is of normal year", () => {
-    const firstDate = new Date(2022, 1, 1); // 2022 is normal year
-    const expectedResult = 1.25;
-    const secondDate = new Date(firstDate.getTime() + expectedResult * 365 * 24 * 60 * 60 * 1000);
-
-    const duration = diffYear(secondDate, firstDate);
-
-    expect(duration).toBeCloseTo(expectedResult, 1);
-  });
-
-  it("should return correct value if firstDate is of leap year", () => {
-    const firstDate = new Date(2016, 1, 1); // 2020 is leap year
-    const expectedResult = 1.25;
-    const secondDate = new Date(firstDate.getTime() + expectedResult * 366 * 24 * 60 * 60 * 1000);
-
-    const duration = diffYear(secondDate, firstDate);
-
-    expect(duration).toBeCloseTo(expectedResult, 1);
-  });
-});