import {
    clearStorageProviders,
    createStorage,
    hasStorageProvider,
} from "@suaveplan/storage/factory";
import {
    afterEach,
    beforeEach,
    describe,
    expect,
    it,
} from "@suaveplan/testing/runner";
import { IDBFactory } from "fake-indexeddb";
import { IndexedDbStorage } from "../indexeddb-storage/indexeddb-storage.js";
import type { IdbFactoryLike } from "../types/idb-like.types.js";
import { registerIndexedDbProvider } from "./registry.js";

function fakeFactory(): IdbFactoryLike {
    const real = new IDBFactory();
    return { open: (n, v) => real.open(n, v) as never };
}

describe("registerIndexedDbProvider", () => {
    beforeEach(() => {
        clearStorageProviders();
    });
    afterEach(() => {
        clearStorageProviders();
    });

    it("registers the indexeddb provider and resolves it via createStorage", {
        timeout: 5000,
    }, async () => {
        registerIndexedDbProvider();
        expect(hasStorageProvider("indexeddb")).toBe(true);
        const storage = createStorage({
            type: "indexeddb" as never,
            config: {
                dbName: `t-${Date.now()}-${Math.random()}`,
                indexedDB: fakeFactory(),
            } as never,
        });
        expect(storage).toBeInstanceOf(IndexedDbStorage);
        await (storage as IndexedDbStorage).set("k", new Uint8Array([1]));
        expect(await (storage as IndexedDbStorage).get("k")).toEqual(
            new Uint8Array([1])
        );
    });

    it("is idempotent across repeated registerIndexedDbProvider calls", {
        timeout: 5000,
    }, () => {
        registerIndexedDbProvider();
        registerIndexedDbProvider();
        registerIndexedDbProvider();
        expect(hasStorageProvider("indexeddb")).toBe(true);
    });
});