import { describe, expect, it } from "bun:test";

import { fetchFromMultipleSources } from "./fetchFromMultipleSources";

describe("fetchFromMultipleSources", () => {
  it("no promises, throws exception", () => {
    expect(() => fetchFromMultipleSources([])).toThrow(
      "fetchPromises cannot be empty",
    );
  });

  it("has promises with valid responses, returns first one with value", async () => {
    const { result } = await fetchFromMultipleSources<number>([
      () => Promise.resolve(undefined),
      () => Promise.resolve(null),
      () => Promise.reject(),
      () => Promise.resolve(2),
      () => Promise.resolve(3),
    ]);

    expect(result).toEqual(2);
  });

  it("has promises with valid responses, contains no errors", async () => {
    const { errors } = await fetchFromMultipleSources<number>([
      () => Promise.resolve(undefined),
      () => Promise.resolve(null),
      () => Promise.reject(),
      () => Promise.resolve(2),
      () => Promise.resolve(3),
    ]);

    expect(errors).toBeNull();
  });

  it("has promises with no valid responses, returns null", async () => {
    const { result } = await fetchFromMultipleSources<number>([
      () => Promise.resolve(null),
      () => Promise.reject("error"),
      () => Promise.resolve(undefined),
    ]);

    expect(result).toBeNull();
  });

  it("has promises with no valid responses, contains error", async () => {
    const { errors } = await fetchFromMultipleSources<number>([
      () => Promise.resolve(null),
      () => Promise.reject("error"),
      () => Promise.reject(new Error("error")),
      () => Promise.resolve(undefined),
    ]);

    expect(errors).toEqual(["error", new Error("error")]);
  });

  it("has promises but cache has value, returns cached value", async () => {
    const { result } = await fetchFromMultipleSources<number>(
      [
        () => Promise.resolve(null),
        () => Promise.reject("error"),
        () => Promise.resolve(undefined),
      ],
      {
        fetchFromCache: () => Promise.resolve(-1),
        saveInCache: async () => {},
      },
    );

    expect(result).toEqual(-1);
  });

  it("has promises but cache has value, contains no errors", async () => {
    const { errors } = await fetchFromMultipleSources<number>(
      [
        () => Promise.resolve(null),
        () => Promise.reject("error"),
        () => Promise.resolve(undefined),
      ],
      {
        fetchFromCache: () => Promise.resolve(-1),
        saveInCache: async () => {},
      },
    );

    expect(errors).toBeNull();
  });

  it("has promises, no cached value, no valid response, should not save in cache", async () => {
    let actual;
    await fetchFromMultipleSources<number>(
      [
        () => Promise.resolve(null),
        () => Promise.reject(),
        () => Promise.resolve(undefined),
      ],
      {
        fetchFromCache: () => Promise.resolve(null),
        saveInCache: async (value) => {
          actual = value;
        },
      },
    );

    expect(actual).toBeUndefined();
  });

  it("has promises, no cached value, has valid response, should save in cache", async () => {
    let actual: number | undefined;
    await fetchFromMultipleSources<number>(
      [
        () => Promise.resolve(null),
        () => Promise.reject(),
        () => Promise.resolve(3),
      ],
      {
        fetchFromCache: () => Promise.resolve(null),
        saveInCache: async (value) => {
          actual = value;
        },
      },
    );
    const expected = 3;

    expect(actual).toBe(expected);
  });

  it("has promises, no cached value, has valid response, value that was cached is returned", async () => {
    const { result } = await fetchFromMultipleSources(
      [
        () => Promise.resolve(null),
        () => Promise.reject(),
        () => Promise.resolve(3),
      ],
      {
        fetchFromCache: () => Promise.resolve(null),
        saveInCache: async (value) => {},
      },
    );

    expect(result).toBe(3);
  });
});