import { beforeEach, describe, expect, it, vi } from "vitest";

import { note } from "../../terminal/note.js";

import { formatCliCommand } from "../command-format.js";

import { ensureConfigReady, testApi } from "./config-guard.js";

async function withCapturedStdout(run: () => Promise<void>): Promise<string> {

const writes: string[] = [];

const writeSpy = vi.spyOn(process.stdout, "write").mockImplementation(((chunk: unknown) => {

writes.push(String(chunk));

return true;

}) as typeof process.stdout.write);

const writeSpy = vi

.spyOn(process.stdout, "write")

.mockImplementation(

((

chunk: unknown,

encodingOrCallback?: BufferEncoding | ((error?: Error | null) => void),

callback?: (error?: Error | null) => void,

) => {

writes.push(String(chunk));

const done = typeof encodingOrCallback === "function" ? encodingOrCallback : callback;

done?.();

return true;

}) as typeof process.stdout.write,

);

try {

await run();

return writes.join("");

expect(loadAndMaybeMigrateDoctorConfigMock).toHaveBeenCalledTimes(1);

});

it("prevents preflight stdout noise when suppression is enabled", async () => {

it("prevents preflight note noise when suppression is enabled", async () => {

loadAndMaybeMigrateDoctorConfigMock.mockImplementation(async () => {

process.stdout.write("Doctor warnings\n");

note("Doctor warnings", "Config warnings");

return {

snapshot: makeSnapshot(),

baseConfig: {},

expect(output).not.toContain("Doctor warnings");

});

it("allows preflight stdout noise when suppression is not enabled", async () => {

it("allows preflight note noise when suppression is not enabled", async () => {

loadAndMaybeMigrateDoctorConfigMock.mockImplementation(async () => {

process.stdout.write("Doctor warnings\n");

note("Doctor warnings", "Config warnings");

return {

snapshot: makeSnapshot(),

baseConfig: {},

});

expect(output).toContain("Doctor warnings");

});

it("does not suppress unrelated concurrent stdout writes while suppressing preflight notes", async () => {

let releasePreflight: (() => void) | undefined;

let preflightStarted: (() => void) | undefined;

const preflightStartedPromise = new Promise<void>((resolve) => {

preflightStarted = resolve;

});

const releasePreflightPromise = new Promise<void>((resolve) => {

releasePreflight = resolve;

});

loadAndMaybeMigrateDoctorConfigMock.mockImplementation(async () => {

note("Doctor warnings", "Config warnings");

preflightStarted?.();

await releasePreflightPromise;

return {

snapshot: makeSnapshot(),

baseConfig: {},

};

});

let callbackCalled = false;

const output = await withCapturedStdout(async () => {

const ready = runEnsureConfigReady(["message"], true);

await preflightStartedPromise;

process.stdout.write("Concurrent output\n", () => {

callbackCalled = true;

});

releasePreflight?.();

await ready;

});

expect(output).toContain("Concurrent output");

expect(output).not.toContain("Doctor warnings");

expect(callbackCalled).toBe(true);

});

});