// Every method in PROXY_METHODS is sent to the RPC node.
//
// handleRpc answers some methods itself before it reaches its proxy branch. A
// method listed in PROXY_METHODS but answered earlier never reaches the node,
// so the list would name a method that is not proxied
// (https://git.eeqj.de/sneak/AutistMask/issues/326). Each method is sent from
// a page here and must come back with what the node answered.

const { makeStorageStub } = require("./support/storageStub");

async function settle() {
    for (let i = 0; i < 50; i++) await Promise.resolve();
}

afterEach(() => {
    delete global.chrome;
    delete global.fetch;
});

test("every method in PROXY_METHODS reaches the RPC node", async () => {
    jest.resetModules();

    jest.doMock("../src/shared/balances", () => ({
        getProvider: () => ({}),
        refreshBalances: jest.fn(async () => {}),
    }));
    jest.doMock("../src/shared/phishingDomains", () => ({
        isPhishingDomain: () => false,
    }));
    jest.doMock("../src/shared/alarms", () => ({
        BALANCE_REFRESH_ALARM: "balance",
        BALANCE_REFRESH_PERIOD_MINUTES: 1,
        ensureRecurringAlarms: jest.fn(async () => {}),
        registerAlarmHandlers: jest.fn(),
    }));

    // The node answers each method with a value naming that method.
    global.fetch = jest.fn(async (url, opts) => ({
        status: 200,
        json: async () => ({
            jsonrpc: "2.0",
            id: 1,
            result: "node answered " + JSON.parse(opts.body).method,
        }),
    }));

    let messageListener = null;
    global.chrome = {
        storage: makeStorageStub({
            autistmask: {
                networkId: "mainnet",
                wallets: [],
                allowedSites: {},
                deniedSites: {},
            },
        }),
        runtime: {
            getURL: (path) => "chrome-extension://autistmask/" + path,
            onMessage: {
                addListener: (fn) => {
                    messageListener = fn;
                },
            },
            onConnect: { addListener: () => {} },
            lastError: null,
        },
        windows: { onRemoved: { addListener: () => {} } },
        action: { setPopup: () => {} },
    };

    const { PROXY_METHODS } = require("../src/background/index");

    const answers = {};
    const expected = {};
    for (const method of PROXY_METHODS) {
        messageListener(
            { type: "AUTISTMASK_RPC", method, params: [] },
            { origin: "https://dapp.example" },
            (r) => {
                answers[method] = r;
            },
        );
        await settle();
        expected[method] = { result: "node answered " + method };
    }

    expect(PROXY_METHODS.length).toBeGreaterThan(0);
    expect(answers).toEqual(expected);
});