SSH MCP Server
- ssh-mcp
- tests
browser-connectivity-unit.test.ts•11.7 kB
// @ts-nocheck
/* eslint-disable @typescript-eslint/no-unused-vars */
import { JSDOM } from "jsdom";
describe("Browser Connectivity Management - Unit Tests", () => {
let dom: JSDOM;
let window: Window & typeof globalThis;
let document: Document;
beforeEach(() => {
// Set up DOM environment
dom = new JSDOM(
`
<!DOCTYPE html>
<html>
<head><title>Test</title></head>
<body>
<div class="container">
<header>
<h1>SSH Terminal Interface</h1>
<div class="connection-area">
<div id="connection-status" class="status disconnected">Disconnected</div>
<button id="manual-reconnect-btn" style="display: none;">🔄 Manual Reconnect</button>
</div>
<div id="last-connection-info" style="display: none;"></div>
</header>
<main>
<section id="terminal-container">
<h2>Terminal</h2>
<div id="terminal"></div>
</section>
<section id="command-history-container" class="history-panel">
<h2>📜 Command History</h2>
<div id="command-history-list"></div>
</section>
</main>
</div>
<div id="notifications" class="notifications-container"></div>
</body>
</html>
`,
{
pretendToBeVisual: true,
resources: "usable",
},
);
window = dom.window as any;
document = window.document;
global.window = window;
global.document = document;
// Mock xterm.js Terminal
(global as any).Terminal = class MockTerminal {
constructor() {}
open() {}
write() {}
clear() {}
scrollToBottom() {}
onData() {}
onKey() {}
onResize() {}
};
// Mock WebSocket to prevent actual connections
(global as any).WebSocket = class MockWebSocket {
static CONNECTING = 0;
static OPEN = 1;
static CLOSING = 2;
static CLOSED = 3;
readyState = MockWebSocket.CLOSED;
onopen: any = null;
onclose: any = null;
onmessage: any = null;
onerror: any = null;
constructor() {
// Don't actually connect
setTimeout(() => {
if (this.onopen) {
this.readyState = MockWebSocket.OPEN;
this.onopen();
}
}, 100);
}
send() {}
close() {
if (this.onclose) {
this.readyState = MockWebSocket.CLOSED;
this.onclose();
}
}
};
});
afterEach(() => {
dom.window.close();
});
describe("Connection Status Visual Indicators", () => {
it("should update status element with green indicator when connected", () => {
const statusElement = document.getElementById("connection-status");
expect(statusElement).toBeTruthy();
// Simulate connected state update
statusElement!.className = "status connected";
statusElement!.textContent = "🟢 Connected";
statusElement!.style.backgroundColor = "#d4edda";
statusElement!.style.color = "#155724";
statusElement!.style.border = "1px solid #c3e6cb";
// Verify visual indicators
expect(statusElement!.classList.contains("connected")).toBe(true);
expect(statusElement!.textContent).toBe("🟢 Connected");
expect(statusElement!.style.backgroundColor).toBe("rgb(212, 237, 218)"); // Light green
expect(statusElement!.style.color).toBe("rgb(21, 87, 36)"); // Dark green text
});
it("should update status element with red indicator when disconnected", () => {
const statusElement = document.getElementById("connection-status");
expect(statusElement).toBeTruthy();
// Simulate disconnected state update
statusElement!.className = "status disconnected";
statusElement!.textContent = "🔴 Disconnected";
statusElement!.style.backgroundColor = "#f8d7da";
statusElement!.style.color = "#721c24";
statusElement!.style.border = "1px solid #f5c6cb";
// Verify visual indicators
expect(statusElement!.classList.contains("disconnected")).toBe(true);
expect(statusElement!.textContent).toBe("🔴 Disconnected");
expect(statusElement!.style.backgroundColor).toBe("rgb(248, 215, 218)"); // Light red
expect(statusElement!.style.color).toBe("rgb(114, 28, 36)"); // Dark red text
});
});
describe("Notification System", () => {
it("should create and display notifications", () => {
const notificationsContainer = document.getElementById("notifications");
expect(notificationsContainer).toBeTruthy();
// Create a test notification
const notification = document.createElement("div");
notification.className = "notification notification-success";
notification.textContent = "🟢 Connection restored!";
notificationsContainer!.appendChild(notification);
// Verify notification exists
const notifications = notificationsContainer!.children;
expect(notifications.length).toBe(1);
expect(notifications[0].textContent).toContain("🟢 Connection restored!");
expect(notifications[0].classList.contains("notification-success")).toBe(
true,
);
});
it("should support different notification types", () => {
const notificationsContainer = document.getElementById("notifications");
// Test different notification types
const types = ["success", "error", "warning", "info"];
types.forEach((type) => {
const notification = document.createElement("div");
notification.className = `notification notification-${type}`;
notification.textContent = `Test ${type} notification`;
notificationsContainer!.appendChild(notification);
expect(notification.classList.contains(`notification-${type}`)).toBe(
true,
);
});
expect(notificationsContainer!.children.length).toBe(4);
});
});
describe("Manual Reconnect Button", () => {
it("should show manual reconnect button when needed", () => {
const manualReconnectBtn = document.getElementById(
"manual-reconnect-btn",
);
expect(manualReconnectBtn).toBeTruthy();
// Initially hidden
expect(manualReconnectBtn!.style.display).toBe("none");
// Show button for manual reconnection
manualReconnectBtn!.style.display = "inline-block";
// Verify button is visible
expect(manualReconnectBtn!.style.display).toBe("inline-block");
expect(manualReconnectBtn!.textContent).toContain("🔄");
expect(manualReconnectBtn!.textContent).toContain("Manual Reconnect");
});
it("should hide manual reconnect button when connection is restored", () => {
const manualReconnectBtn = document.getElementById(
"manual-reconnect-btn",
);
// Show button first
manualReconnectBtn!.style.display = "inline-block";
expect(manualReconnectBtn!.style.display).toBe("inline-block");
// Hide button when connection restored
manualReconnectBtn!.style.display = "none";
expect(manualReconnectBtn!.style.display).toBe("none");
});
});
describe("Last Connection Info", () => {
it("should display last connection time information", () => {
const lastConnectionInfo = document.getElementById(
"last-connection-info",
);
expect(lastConnectionInfo).toBeTruthy();
// Initially hidden
expect(lastConnectionInfo!.style.display).toBe("none");
// Show connection problems info
const testTime = new Date().toLocaleTimeString();
lastConnectionInfo!.innerHTML = `⚠️ Connectivity problems detected<br><small>Last successful connection: ${testTime}</small>`;
lastConnectionInfo!.style.display = "block";
// Verify info is displayed
expect(lastConnectionInfo!.style.display).toBe("block");
expect(lastConnectionInfo!.textContent).toContain("⚠️");
expect(lastConnectionInfo!.textContent).toContain(
"Connectivity problems",
);
expect(lastConnectionInfo!.textContent).toContain(
"Last successful connection",
);
expect(lastConnectionInfo!.textContent).toContain(testTime);
});
});
describe("Update Queue Functionality", () => {
it("should manage update queue with maximum size limit", () => {
// Simulate update queue management
const maxQueueSize = 50;
let updateQueue: any[] = [];
// Add updates beyond max size
for (let i = 0; i < 100; i++) {
updateQueue.push({
type: "command_executed",
command: `echo "test ${i}"`,
queuedAt: Date.now() + i,
});
// Maintain maximum queue size (keep most recent)
if (updateQueue.length > maxQueueSize) {
updateQueue = updateQueue.slice(-maxQueueSize);
}
}
// Verify queue size limit is enforced
expect(updateQueue.length).toBe(maxQueueSize);
// Verify most recent updates are kept
expect(updateQueue[updateQueue.length - 1].command).toBe(
'echo "test 99"',
);
expect(updateQueue[updateQueue.length - 2].command).toBe(
'echo "test 98"',
);
});
it("should sort queued updates by timestamp for chronological processing", () => {
// Create updates with random timestamps
const updateQueue = [
{
type: "command_executed",
command: "third",
queuedAt: Date.now() + 300,
},
{
type: "command_executed",
command: "first",
queuedAt: Date.now() + 100,
},
{
type: "command_executed",
command: "second",
queuedAt: Date.now() + 200,
},
];
// Sort by timestamp
updateQueue.sort((a, b) => a.queuedAt - b.queuedAt);
// Verify chronological order
expect(updateQueue[0].command).toBe("first");
expect(updateQueue[1].command).toBe("second");
expect(updateQueue[2].command).toBe("third");
});
});
describe("Exponential Backoff Logic", () => {
it("should implement exponential backoff for reconnection attempts", () => {
let reconnectAttempts = 0;
const baseReconnectDelay = 5000; // 5 seconds
let currentReconnectDelay = baseReconnectDelay;
const maxAttempts = 5;
const expectedDelays: number[] = [];
// Simulate multiple reconnection attempts
while (reconnectAttempts < maxAttempts) {
expectedDelays.push(currentReconnectDelay);
reconnectAttempts++;
// Exponential backoff: double the delay each time (max 60 seconds)
currentReconnectDelay = Math.min(currentReconnectDelay * 2, 60000);
}
// Verify exponential backoff pattern
expect(expectedDelays[0]).toBe(5000); // 5s
expect(expectedDelays[1]).toBe(10000); // 10s
expect(expectedDelays[2]).toBe(20000); // 20s
expect(expectedDelays[3]).toBe(40000); // 40s
expect(expectedDelays[4]).toBe(60000); // 60s (capped)
});
it("should reset backoff delay when connection is re-established", () => {
let reconnectAttempts = 3;
const baseReconnectDelay = 5000;
let currentReconnectDelay = 40000; // After 3 failed attempts
// Simulate successful reconnection - reset state
reconnectAttempts = 0;
currentReconnectDelay = baseReconnectDelay;
// Verify state is reset
expect(reconnectAttempts).toBe(0);
expect(currentReconnectDelay).toBe(5000);
});
});
});
Latest Blog Posts
- MCP Moves to the Linux Foundation: Neutral Stewardship for Agentic InfrastructureBy Om-Shree-0709 on .mcpanthropicLinux Foundation
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/LightspeedDMS/ssh-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server