test(ui): cover useChenSession and connectionProgressOverlay and useWork

Commit 9 file(s) from the captured immutable snapshot.

Notable diff evidence:
- expect(markDisconnected).toHaveBeenCalledWith(expect.any(String), { dismissible: true });
- describe("workspace connection progress overlay", () => {
- it("allows post-connection failures to reveal the underlying connector output", () => {

Author: ZhaoJiSen

ui/chen/composables/useChenSession.test.ts

@@ -92,7 +92,7 @@ describe("chen session dialogs", () => {
     await Promise.resolve();
     socket.onclose?.({ code: 1006, reason: "" } as CloseEvent);
 
-    expect(markDisconnected).toHaveBeenCalled();
+    expect(markDisconnected).toHaveBeenCalledWith(expect.any(String), { dismissible: true });
   });
 
   it("marks a session as disconnected when its socket closes before ready", async () => {

ui/components/Workspace/connectionProgressOverlay.test.ts

@@ -0,0 +1,17 @@
+import { describe, expect, it } from "vitest";
+import overlay from "./connectionProgressOverlay.vue?raw";
+
+describe("workspace connection progress overlay", () => {
+  it("allows post-connection failures to reveal the underlying connector output", () => {
+    expect(overlay).toContain("dismissible?: boolean");
+    expect(overlay).toContain('v-show="!dismissed"');
+    expect(overlay).toContain('v-if="failed && dismissible"');
+    expect(overlay).toContain('class="absolute top-6 right-6 z-10"');
+    expect(overlay).toContain('@click="dismiss"');
+  });
+
+  it("preserves normalized diagnostic line breaks", () => {
+    expect(overlay).toContain("whitespace-pre-wrap");
+    expect(overlay).toContain("wrap-break-word");
+  });
+});

ui/composables/useWorkspaceTabs.sessionStatus.test.ts

@@ -45,12 +45,12 @@ describe("workspace session disconnect status", () => {
     expect(tabs.tabs.value[0]?.status).toBe("disconnected");
   });
 
-  it("keeps a ready session and its disconnect reason", () => {
+  it("keeps a ready session and a safe disconnect reason", () => {
     const pane = tabs.openSession(asset, { protocol: "ssh", account: "root", newTab: true });
     pane.payload = { id: "token" };
     tabs.markSessionConnected(pane.id);
 
-    tabs.markSessionDisconnected(pane.id, "connection closed");
+    tabs.markSessionDisconnected(pane.id, "\x1B[31mconnection closed\x1B[0m");
 
     expect(pane.status).toBe("disconnected");
     expect(pane.payload).toEqual({ id: "token" });
@@ -66,11 +66,16 @@ describe("workspace session disconnect status", () => {
     const pane = tabs.openSetupSession(asset);
     tabs.startSessionConnection(pane.id, { protocol: "ssh", account: "root" });
     tabs.markSessionConnected(pane.id);
-    tabs.markSessionDisconnected(pane.id, "Koko 已结束会话：连接建立失败");
+    tabs.markSessionDisconnected(pane.id, "Koko 已结束会话：连接建立失败", { dismissible: true });
 
     expect(pane.status).toBe("disconnected");
     expect(pane.connectionProgress).toBe("connected");
     expect(pane.connectionFailure).toBe("Koko 已结束会话：连接建立失败");
+    expect(pane.connectionFailureDismissible).toBe(true);
+    expect(tabs.tabs.value[0]?.connectionFailureDismissible).toBe(true);
+
+    tabs.markSessionConnecting(pane.id);
+    expect(pane.connectionFailureDismissible).toBeUndefined();
   });
 
   it("increments the connection attempt before a new request can update the pane", () => {

ui/koko/tests/kubernetes/kubernetesWorkspace.test.ts

@@ -19,4 +19,10 @@ describe("kubernetes workspace click typing", () => {
     expect(kubernetesWorkspace).not.toMatch(/\.xterm-scrollable-element\s*\{[^}]*padding:/);
     expect(kubernetesWorkspace).not.toContain("background-color: transparent !important");
   });
+
+  it("marks post-connection protocol and transport failures as dismissible", () => {
+    expect(kubernetesWorkspace).toContain("const connectorConnected = ref(false)");
+    expect(kubernetesWorkspace).toContain("{ dismissible: connectorConnected.value }");
+    expect(kubernetesWorkspace).toContain("const stopFailureListener = terminalSocket.onFailure((failure) =>");
+  });
 });

ui/koko/tests/sftp/sftp.test.ts

@@ -1,6 +1,6 @@
 import type { FileTransferStatus, FileTransferTask } from "@jumpserver/connectors-core";
 import { afterEach, describe, expect, it, vi } from "vitest";
-import { ref } from "vue";
+import { effectScope, ref } from "vue";
 
 import { encodeSftpBinaryFrame, parseSftpBinaryFrame } from "#koko/composables/sftp/core/codec";
 import {
@@ -19,6 +19,7 @@ import {
   SftpSocketFailureCode,
   SftpWebSocketProtocol
 } from "#koko/composables/sftp/protocol";
+import { useSftpFileManager } from "#koko/composables/sftp/useSftpFileManager";
 import {
   SFTP_UPLOAD_CHUNK_SIZE,
   SftpPathNotFoundError,
@@ -33,6 +34,10 @@ import { finishedTransferCount, sftpTransferGroupStatus, sftpTransferProgress }
 import enMessages from "../../../../i18n/locales/en.json";
 import zhMessages from "../../../../i18n/locales/zh.json";
 
+vi.mock("#koko/host", () => ({
+  useKokoHostAdapter: () => ({})
+}));
+
 const context = {
   component: "koko" as const,
   tokenId: "initial-token",
@@ -174,6 +179,22 @@ describe("sFTP browser protocol", () => {
     expect(socket.connected.value).toBe(false);
   });
 
+  it("uses a server SFTP error as the fatal session reason", () => {
+    vi.stubGlobal("WebSocket", FakeWebSocket as unknown as typeof WebSocket);
+    vi.stubGlobal("useI18n", () => ({ t: (key: string) => key }));
+    const scope = effectScope();
+    const manager = scope.run(() => useSftpFileManager(ref(context)))!;
+    const fake = FakeWebSocket.instances.at(-1)!;
+
+    fake.open();
+    fake.receive({ id: "error", type: SftpMessageType.Error, err: "Permission denied" });
+
+    expect(manager.fatalError.value).toBe(true);
+    expect(manager.hasConnected.value).toBe(true);
+    expect(manager.error.value).toBe("koko.fileManagement.pathPermissionDenied");
+    scope.stop();
+  });
+
   it("disconnects when koko stops sending heartbeats", () => {
     vi.useFakeTimers();
     const { fake, socket } = openSocket();

ui/koko/tests/sftp/sftpTransportCore.test.ts

@@ -27,6 +27,7 @@ function createSocket(connected = true) {
   } = {
     socket: ref(null),
     connected: ref(connected),
+    hasConnected: ref(connected),
     failure: ref(null),
     close: vi.fn(),
     connect: vi.fn(),

ui/koko/tests/terminal/terminalConnection.test.ts

@@ -8,6 +8,8 @@ import {
 } from "#koko/composables/terminal/protocol";
 import { useKokoTerminalHeartbeat } from "#koko/composables/terminal/useTerminalHeartbeat";
 import { useKokoTerminalTransport } from "#koko/composables/terminal/useTerminalTransport";
+import { normalizeConnectionFailure } from "~/utils/connectionFailure";
+import terminalSocketSource from "../../composables/terminal/useTerminalSocket.ts?raw";
 
 afterEach(() => {
   vi.useRealTimers();
@@ -30,21 +32,28 @@ it("distinguishes Koko session end, Koko timeout, offline and unexplained closes
   expect(describeTerminalClose(abnormal, "", true).source).toBe("koko");
 });
 
-it("uses raw startup output for an early close and clears it once ready", () => {
+it("uses sanitized startup bytes for an early close and clears them once ready", () => {
   const capture = createKokoStartupOutputCapture();
-  const encoded = new TextEncoder().encode("sqlserver: 连接被拒绝");
+  const fallback = "Koko 已结束会话：资产连接已结束";
+  const encoded = new TextEncoder().encode("\u001b[31m认证失败\u001b[0m");
+  const prefixBytes = new TextEncoder().encode("\u001b[31m").length;
+  const splitAt = prefixBytes + 1;
 
-  capture.append(encoded.slice(0, 13));
-  capture.append(encoded.slice(13));
-  expect(resolveKokoTerminalCloseMessage(capture.take(), "Koko 已结束会话：资产连接已结束")).toBe(
-    "sqlserver: 连接被拒绝"
+  expect(new TextEncoder().encode("认").length).toBeGreaterThan(1);
+  capture.append(encoded.slice(0, splitAt));
+  capture.append(encoded.slice(splitAt));
+  const startup = normalizeConnectionFailure(capture.take());
+
+  expect(startup).toBe("认证失败");
+  expect(normalizeConnectionFailure("开始连接\r\nssh: handshake failed: EOF")).toBe(
+    "开始连接\nssh: handshake failed: EOF"
   );
+  expect(startup).not.toContain("\u001b");
+  expect(resolveKokoTerminalCloseMessage(startup, fallback)).toBe("认证失败");
 
   capture.markReady();
   capture.append(new TextEncoder().encode("must not replace the close reason"));
-  expect(resolveKokoTerminalCloseMessage(capture.take(), "Koko 已结束会话：资产连接已结束")).toBe(
-    "Koko 已结束会话：资产连接已结束"
-  );
+  expect(resolveKokoTerminalCloseMessage(normalizeConnectionFailure(capture.take()), fallback)).toBe(fallback);
 });
 
 it("keeps only the last 8 KiB of startup output", () => {
@@ -58,6 +67,14 @@ it("keeps only the last 8 KiB of startup output", () => {
   expect(capture.take()).toBe(`${"x".repeat(limit - 4)}tail`);
 });
 
+it("reads sanitized startup bytes on close instead of the xterm buffer", () => {
+  expect(terminalSocketSource).toContain("normalizeConnectionFailure(startupOutput.take())");
+  expect(terminalSocketSource).toContain("socketOpened = true");
+  expect(terminalSocketSource).toContain("{ dismissible: socketOpened }");
+  expect(terminalSocketSource).toContain("onTerminalReady: startupOutput.markReady");
+  expect(terminalSocketSource).not.toContain("getXTerminalLineContent");
+});
+
 it("sends heartbeats only on open sockets, updates send time and stops after close", () => {
   vi.useFakeTimers();
   const socket = { readyState: WebSocket.CONNECTING as number, send: vi.fn() };

ui/lion/workspaces/useBaseWorkspaceSession.test.ts

@@ -1,6 +1,6 @@
 import type { WorkspaceSessionTab } from "~/composables/useWorkspaceTabs";
-import { effectScope, ref } from "vue";
 import { beforeEach, describe, expect, it, vi } from "vitest";
+import { effectScope, ref } from "vue";
 
 const markSessionConnected = vi.fn();
 const markSessionFailed = vi.fn();
@@ -20,6 +20,26 @@ describe("lion workspace session preparation", () => {
     createLionConnectTicket.mockResolvedValue("ticket-1");
   });
 
+  it("fails the workspace when its connection token is missing", async () => {
+    const tab = ref({
+      id: "tab-1",
+      assetId: "asset-1",
+      protocol: "rdp",
+      account: "root",
+      payload: {}
+    } as WorkspaceSessionTab);
+    const scope = effectScope();
+    const session = scope.run(() => useBaseWorkspaceSession(tab))!;
+
+    await session.prepareSession();
+
+    expect(markSessionFailed).toHaveBeenCalledWith(
+      { tabId: "tab-1", assetId: "asset-1", protocol: "rdp", account: "root" },
+      "Missing connection token"
+    );
+    scope.stop();
+  });
+
   it("waits for Guacamole readiness before marking the session connected", async () => {
     const tab = ref({
       id: "tab-1",

ui/utils/connectionFailure.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { normalizeConnectionFailure } from "~/utils/connectionFailure";
+
+describe("normalizeConnectionFailure", () => {
+  it("removes terminal control sequences and HTML while preserving readable lines", () => {
+    expect(
+      normalizeConnectionFailure("\u001B[31m<p>Connecting</p>\r\n<p>Authentication failed\u0000</p>\u001B[0m")
+    ).toBe("Connecting\nAuthentication failed");
+  });
+
+  it("drops a binary prefix while retaining the terminal diagnostic", () => {
+    expect(normalizeConnectionFailure("\u0000\u0000\u0000\u00102.3.4开始连接 root: ssh: handshake failed: EOF")).toBe(
+      "开始连接 root: ssh: handshake failed: EOF"
+    );
+  });
+
+  it("removes binary packets embedded between terminal lines", () => {
+    expect(
+      normalizeConnectionFailure(
+        "开始连接 root(root)\u0000.\u0001.\u0002.\u0003.\u0004.\u0005.\u0006.\u0007.\u0008.\u0009开始连接 root(root) error: ssh: handshake failed: EOF"
+      )
+    ).toBe("开始连接 root(root)\n开始连接 root(root) error: ssh: handshake failed: EOF");
+  });
+
+  it("keeps the last ten non-empty lines", () => {
+    const message = Array.from({ length: 12 }, (_, index) => `line-${index + 1}`).join("\n");
+
+    expect(normalizeConnectionFailure(message)).toBe(
+      Array.from({ length: 10 }, (_, index) => `line-${index + 3}`).join("\n")
+    );
+  });
+});