Laca-City/frontend/node_modules/next/dist/trace/trace.test.js

"use strict";
Object.defineProperty(exports, "__esModule", {
    value: true
});
const _promises = require("fs/promises");
const _path = require("path");
const _os = require("os");
const _shared = require("./shared");
const _trace = require("./trace");
describe("Trace", ()=>{
    beforeEach(()=>{
        (0, _trace.initializeTraceState)({
            lastId: 0,
            shouldSaveTraceEvents: true
        });
        (0, _trace.clearTraceEvents)();
    });
    describe("Tracer", ()=>{
        it("traces a block of code", async ()=>{
            const tmpDir = await (0, _promises.mkdtemp)((0, _path.join)((0, _os.tmpdir)(), "json-reporter"));
            (0, _shared.setGlobal)("distDir", tmpDir);
            (0, _shared.setGlobal)("phase", "anything");
            const root = (0, _trace.trace)("root-span", undefined, {
                "some-tag": "some-value"
            });
            root.traceChild("child-span").traceFn(()=>null);
            await root.traceChild("async-child-span").traceAsyncFn(async ()=>{
                const delayedPromise = new Promise((resolve)=>{
                    setTimeout(resolve, 100);
                });
                await delayedPromise;
            });
            root.stop();
            const traceEvents = (0, _trace.getTraceEvents)();
            expect(traceEvents.length).toEqual(3);
            expect(traceEvents[0].name).toEqual("child-span");
            expect(traceEvents[1].name).toEqual("async-child-span");
            expect(traceEvents[2].name).toEqual("root-span");
            // Check that the serialized .next/trace file looks correct.
            await (0, _trace.flushAllTraces)();
            const traceFilename = (0, _path.join)(tmpDir, "trace");
            const serializedTraces = JSON.parse(await (0, _promises.readFile)(traceFilename, "utf-8"));
            expect(serializedTraces).toMatchObject([
                {
                    id: 2,
                    name: "child-span",
                    parentId: 1,
                    startTime: expect.any(Number),
                    timestamp: expect.any(Number),
                    duration: expect.any(Number),
                    tags: {}
                },
                {
                    id: 3,
                    name: "async-child-span",
                    parentId: 1,
                    startTime: expect.any(Number),
                    timestamp: expect.any(Number),
                    duration: expect.any(Number),
                    tags: {}
                },
                {
                    id: 1,
                    name: "root-span",
                    startTime: expect.any(Number),
                    timestamp: expect.any(Number),
                    duration: expect.any(Number),
                    tags: {
                        "some-tag": "some-value"
                    }
                }
            ]);
        });
    });
    describe("Worker", ()=>{
        it("exports and initializes trace state", ()=>{
            const root = (0, _trace.trace)("root-span");
            expect(root.getId()).toEqual(1);
            const traceState = (0, _trace.exportTraceState)();
            expect(traceState.lastId).toEqual(1);
            (0, _trace.initializeTraceState)({
                lastId: 101
            });
            const span = (0, _trace.trace)("another-span");
            expect(span.getId()).toEqual(102);
        });
        it("trace data is serializable to a worker", async ()=>{
            const root = (0, _trace.trace)("root-span");
            root.traceChild("child-span").traceFn(()=>null);
            root.stop();
            const traceEvents = (0, _trace.getTraceEvents)();
            expect(traceEvents.length).toEqual(2);
            // This is a proxy check to make sure the object would be serializable
            // to a worker. It will fail if the data contains some unserializable
            // objects like BigInt.
            const clone = JSON.parse(JSON.stringify(traceEvents));
            expect(clone).toEqual(traceEvents);
        });
        it("correctly reports trace data from multiple workers", ()=>{
            // This test simulates workers creating traces and propagating them
            // back to the main process for recording. It doesn't use
            // actual workers since they are more difficult to set up in tests.
            (0, _trace.initializeTraceState)({
                lastId: 5,
                defaultParentSpanId: 1,
                shouldSaveTraceEvents: true
            });
            const worker1Span = (0, _trace.trace)("worker1");
            worker1Span.traceChild("webpack-compilation1").traceFn(()=>null);
            worker1Span.stop();
            const worker1Traces = (0, _trace.getTraceEvents)();
            expect(worker1Traces.length).toEqual(2);
            // Repeat for a second worker.
            (0, _trace.clearTraceEvents)();
            (0, _trace.initializeTraceState)({
                lastId: 10,
                defaultParentSpanId: 1,
                shouldSaveTraceEvents: true
            });
            const worker2Span = (0, _trace.trace)("worker2");
            worker2Span.traceChild("webpack-compilation2").traceFn(()=>null);
            worker2Span.stop();
            const worker2Traces = (0, _trace.getTraceEvents)();
            expect(worker2Traces.length).toEqual(2);
            // Now simulate the traces in the main process and record the traces
            // from each worker.
            (0, _trace.clearTraceEvents)();
            (0, _trace.initializeTraceState)({
                lastId: 0,
                shouldSaveTraceEvents: true
            });
            const root = (0, _trace.trace)("next-build");
            root.traceChild("some-child-span").traceFn(()=>null);
            (0, _trace.recordTraceEvents)(worker1Traces);
            expect((0, _trace.exportTraceState)().lastId).toEqual(8);
            (0, _trace.recordTraceEvents)(worker2Traces);
            expect((0, _trace.exportTraceState)().lastId).toEqual(13);
            root.traceChild("another-child-span").traceFn(()=>null);
            root.stop();
            // Check that the final output looks correct.
            const allTraces = (0, _trace.getTraceEvents)();
            expect(allTraces.length).toEqual(7);
            const firstSpan = allTraces[0];
            expect(firstSpan.name).toEqual("some-child-span");
            expect(firstSpan.id).toEqual(2);
            expect(firstSpan.parentId).toEqual(1);
            const worker1Child = allTraces[1];
            expect(worker1Child.name).toEqual("webpack-compilation1");
            expect(worker1Child.id).toEqual(7);
            expect(worker1Child.parentId).toEqual(6);
            const worker1Root = allTraces[2];
            expect(worker1Root.name).toEqual("worker1");
            expect(worker1Root.id).toEqual(6);
            expect(worker1Root.parentId).toEqual(1);
            const worker2Child = allTraces[3];
            expect(worker2Child.name).toEqual("webpack-compilation2");
            expect(worker2Child.id).toEqual(12);
            expect(worker2Child.parentId).toEqual(11);
            const worker2Root = allTraces[4];
            expect(worker2Root.name).toEqual("worker2");
            expect(worker2Root.id).toEqual(11);
            expect(worker2Root.parentId).toEqual(1);
            const lastChildSpan = allTraces[5];
            expect(lastChildSpan.name).toEqual("another-child-span");
            expect(lastChildSpan.id).toEqual(14);
            expect(lastChildSpan.parentId).toEqual(1);
            const rootSpan = allTraces[6];
            expect(rootSpan.name).toEqual("next-build");
            expect(rootSpan.id).toEqual(1);
            expect(rootSpan.parentId).toBeUndefined();
        });
    });
});

//# sourceMappingURL=trace.test.js.map