// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import { assert } from 'chai';
import { TraceLoader } from '../../../testing/TraceLoader.js';
import * as Trace from '../trace.js';
describe('AuctionWorkletsHandler', function () {
    beforeEach(() => {
        Trace.Handlers.ModelHandlers.AuctionWorklets.reset();
    });
    const expectedPIDsAndTypes = [
        {
            pid: 776435,
            type: "seller" /* Trace.Types.Events.AuctionWorkletType.SELLER */,
        },
        {
            pid: 776436,
            type: "bidder" /* Trace.Types.Events.AuctionWorkletType.BIDDER */,
        },
        {
            pid: 776449,
            type: "bidder" /* Trace.Types.Events.AuctionWorkletType.BIDDER */,
        },
    ];
    it('parses and finds worklets from the metadata events', async function () {
        const events = await TraceLoader.rawEvents(this, 'fenced-frame-fledge.json.gz');
        for (const event of events) {
            Trace.Handlers.ModelHandlers.AuctionWorklets.handleEvent(event);
        }
        await Trace.Handlers.ModelHandlers.AuctionWorklets.finalize();
        const data = Trace.Handlers.ModelHandlers.AuctionWorklets.data();
        assert.strictEqual(data.worklets.size, 3);
        const actualPIDsAndTypes = Array.from(data.worklets.values()).map(worklet => ({ pid: worklet.pid, type: worklet.type }));
        assert.deepEqual(actualPIDsAndTypes, expectedPIDsAndTypes);
    });
    it('finds the utility thread for each worklet', async function () {
        const events = await TraceLoader.rawEvents(this, 'fenced-frame-fledge.json.gz');
        for (const event of events) {
            Trace.Handlers.ModelHandlers.AuctionWorklets.handleEvent(event);
        }
        await Trace.Handlers.ModelHandlers.AuctionWorklets.finalize();
        const data = Trace.Handlers.ModelHandlers.AuctionWorklets.data();
        const expectedCrUtilityPIDsAndTIDs = [
            {
                pid: 776435,
                tid: 1,
            },
            {
                pid: 776436,
                tid: 1,
            },
            {
                pid: 776449,
                tid: 1,
            },
        ];
        const actualUtilityPIDsAndTIDs = Array.from(data.worklets.values())
            .map(worklet => ({ pid: worklet.pid, tid: worklet.args.data.utilityThread.tid }));
        assert.deepEqual(actualUtilityPIDsAndTIDs, expectedCrUtilityPIDsAndTIDs);
    });
    it('finds the AuctionV8HelperThread thread for each worklet', async function () {
        const events = await TraceLoader.rawEvents(this, 'fenced-frame-fledge.json.gz');
        for (const event of events) {
            Trace.Handlers.ModelHandlers.AuctionWorklets.handleEvent(event);
        }
        await Trace.Handlers.ModelHandlers.AuctionWorklets.finalize();
        const data = Trace.Handlers.ModelHandlers.AuctionWorklets.data();
        const expectedAuctionV8PIDsAndTIDs = [
            {
                pid: 776435,
                tid: 6,
            },
            {
                pid: 776436,
                tid: 6,
            },
            {
                pid: 776449,
                tid: 6,
            },
        ];
        const actualAuctionV8PIDsAndTIDs = Array.from(data.worklets.values())
            .map(worklet => ({ pid: worklet.pid, tid: worklet.args.data.v8HelperThread.tid }));
        assert.deepEqual(actualAuctionV8PIDsAndTIDs, expectedAuctionV8PIDsAndTIDs);
    });
    it('pairs up Running and DoneWith events', async function () {
        // All of these events have a matching pair of events (see
        // AuctionWorkletsHandler for more information on these events.)
        const events = await TraceLoader.rawEvents(this, 'fenced-frame-fledge.json.gz');
        for (const event of events) {
            Trace.Handlers.ModelHandlers.AuctionWorklets.handleEvent(event);
        }
        await Trace.Handlers.ModelHandlers.AuctionWorklets.finalize();
        const data = Trace.Handlers.ModelHandlers.AuctionWorklets.data();
        assert.strictEqual(data.worklets.size, 3);
        for (const worklet of data.worklets.values()) {
            assert.exists(worklet.args.data.runningInProcessEvent);
            assert.exists(worklet.args.data.doneWithProcessEvent);
        }
    });
    it('can find worklets just from the DoneWith events', async function () {
        const actualEvents = await TraceLoader.rawEvents(this, 'fenced-frame-fledge.json.gz');
        const events = actualEvents.filter(e => {
            // Remove all RunningWith events
            return Trace.Types.Events.isAuctionWorkletRunningInProcess(e) === false;
        });
        for (const event of events) {
            Trace.Handlers.ModelHandlers.AuctionWorklets.handleEvent(event);
        }
        await Trace.Handlers.ModelHandlers.AuctionWorklets.finalize();
        const data = Trace.Handlers.ModelHandlers.AuctionWorklets.data();
        assert.strictEqual(data.worklets.size, 3);
        // The expected data is ordered by PID; this order is correct in the
        // un-modified set of events but because this event removes some events, we
        // sort the found worklets by PID to ensure that the comparison is still
        // successful. We are not interested in the order these events come.
        const actualPIDsAndTypes = Array.from(data.worklets.values())
            .sort((a, b) => a.pid - b.pid)
            .map(worklet => ({ pid: worklet.pid, type: worklet.type }));
        assert.deepEqual(actualPIDsAndTypes, expectedPIDsAndTypes);
    });
    it('can find worklets just from the RunningIn events', async function () {
        const actualEvents = await TraceLoader.rawEvents(this, 'fenced-frame-fledge.json.gz');
        const events = actualEvents.filter(e => {
            // Remove all DoneWith events
            return Trace.Types.Events.isAuctionWorkletDoneWithProcess(e) === false;
        });
        for (const event of events) {
            Trace.Handlers.ModelHandlers.AuctionWorklets.handleEvent(event);
        }
        await Trace.Handlers.ModelHandlers.AuctionWorklets.finalize();
        const data = Trace.Handlers.ModelHandlers.AuctionWorklets.data();
        assert.strictEqual(data.worklets.size, 3);
        // The expected data is ordered by PID; this order is correct in the
        // un-modified set of events but because this event removes some events, we
        // sort the found worklets by PID to ensure that the comparison is still
        // successful. We are not interested in the order these events come.
        const actualPIDsAndTypes = Array.from(data.worklets.values())
            .sort((a, b) => a.pid - b.pid)
            .map(worklet => ({ pid: worklet.pid, type: worklet.type }));
        assert.deepEqual(actualPIDsAndTypes, expectedPIDsAndTypes);
    });
});
//# sourceMappingURL=AuctionWorkletsHandler.test.js.map