import { test, expect, vi } from "vitest";
import { importPlugins } from "./importPlugins.js";
import { PluginImportError } from "./errors.js";
import { newLixFile, openLixInMemory } from "@lix-js/sdk";
test("it should preprocess a plugin", async () => {
    global.fetch = vi.fn().mockResolvedValue({
        ok: true,
        text: vi.fn().mockResolvedValue("export default { key: 'mock' }"),
    });
    const lix = await openLixInMemory({ blob: await newLixFile() });
    const result = await importPlugins({
        lix,
        settings: {
            baseLocale: "en",
            locales: ["en"],
            modules: ["https://mock.com/module.js"],
        },
        preprocessPluginBeforeImport: async (moduleText) => {
            return moduleText.replace("mock", "preprocessed");
        },
    });
    expect(result.plugins.length).toBe(1);
    expect(result.errors.length).toBe(0);
    expect(result.plugins[0]?.key).toBe("preprocessed");
});
test("if a fetch fails, a plugin import error is expected", async () => {
    global.fetch = vi.fn().mockResolvedValue({
        ok: false,
        statusText: "HTTP 404",
    });
    const lix = await openLixInMemory({ blob: await newLixFile() });
    const result = await importPlugins({
        lix,
        settings: {
            baseLocale: "en",
            locales: ["en"],
            modules: ["https://mock.com/module.js"],
        },
    });
    expect(global.fetch).toHaveBeenCalled();
    expect(result.plugins.length).toBe(0);
    expect(result.errors.length).toBe(1);
    expect(result.errors[0]).toBeInstanceOf(PluginImportError);
});
test("if a network error occurs during fetch, a plugin import error is expected", async () => {
    const lix = await openLixInMemory({ blob: await newLixFile() });
    global.fetch = vi.fn().mockRejectedValue(new Error("Network error"));
    const result = await importPlugins({
        lix,
        settings: {
            baseLocale: "en",
            locales: ["en"],
            modules: ["https://example.com/non-existent-paraglide-plugin.js"],
        },
    });
    expect(global.fetch).toHaveBeenCalled();
    expect(result.plugins.length).toBe(0);
    expect(result.errors.length).toBe(1);
    expect(result.errors[0]).toBeInstanceOf(PluginImportError);
    expect(result.errors[0]?.message).toContain("https://example.com/non-existent-paraglide-plugin.js");
    expect(result.errors[0]?.message).toContain("Network error");
});
test("it should filter message lint rules for legacy reasons", async () => {
    global.fetch = vi.fn().mockResolvedValue({
        ok: true,
        text: vi
            .fn()
            .mockResolvedValue("export default { id: 'messageLintRule.something' }"),
    });
    const lix = await openLixInMemory({ blob: await newLixFile() });
    const result = await importPlugins({
        lix,
        settings: {
            baseLocale: "en",
            locales: ["en"],
            modules: ["https://mock.com/module.js"],
        },
    });
    expect(result.plugins.length).toBe(0);
    expect(result.errors.length).toBe(0);
});
// more tests are found in cache.test.ts
test("cache should work", async () => {
    global.fetch = vi.fn().mockResolvedValue({
        ok: false,
    });
    const mockModulePath = "https://mock.com/module.js";
    const mockModuleCachePath = "/cache/plugins/31i1etp0l413h";
    const lix = await openLixInMemory({ blob: await newLixFile() });
    await lix.db
        .insertInto("file")
        .values({
        path: mockModuleCachePath,
        data: new TextEncoder().encode("export default { key: 'mock' }"),
    })
        .execute();
    const result = await importPlugins({
        lix,
        settings: {
            baseLocale: "en",
            locales: ["en"],
            modules: [mockModulePath],
        },
    });
    expect(result.errors).lengthOf(0);
    expect(result.plugins).lengthOf(1);
    expect(result.plugins[0]?.key).toBe("mock");
});
//# sourceMappingURL=importPlugins.test.js.map