Andrey/uptime-kuma
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add a testcase

Browse Source
This commit is contained in:
Frank Elsinga 2026-01-02 07:43:35 +01:00 committed by GitHub
parent 951b375a60
commit 3cb3e7a8c3
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
1 changed files with 264 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

264
test/backend-test/monitors/test-gamedig.js Normal file
View File

@ -0,0 +1,264 @@
const { describe, test, mock } = require("node:test");
const assert = require("node:assert");
const { GameDigMonitorType } = require("../../../server/monitor-types/gamedig");
const { UP, DOWN, PENDING } = require("../../../src/util");
const net = require("net");
const Gamedig = require("gamedig");
describe("GameDig Monitor", () => {
test("check() sets status to UP when Gamedig.query returns valid server response", async () => {
const gamedigMonitor = new GameDigMonitorType();
mock.method(Gamedig, "query", async () => {
return {
name: "Test Minecraft Server",
ping: 42,
players: [],
};
});
const monitor = {
hostname: "127.0.0.1",
port: 25565,
game: "minecraft",
gamedigGivenPortOnly: true,
};
const heartbeat = {
msg: "",
status: PENDING,
};
try {
await gamedigMonitor.check(monitor, heartbeat, {});
assert.strictEqual(heartbeat.status, UP);
assert.strictEqual(heartbeat.msg, "Test Minecraft Server");
assert.strictEqual(heartbeat.ping, 42);
} finally {
mock.restoreAll();
}
});
test("check() resolves hostname to IP address when hostname is not an IP", async () => {
const gamedigMonitor = new GameDigMonitorType();
mock.method(Gamedig, "query", async (options) => {
assert.ok(
net.isIP(options.host) !== 0,
`Expected IP address, got ${options.host}`
);
return {
name: "Test Server",
ping: 50,
};
});
const monitor = {
hostname: "localhost",
port: 25565,
game: "minecraft",
gamedigGivenPortOnly: false,
};
const heartbeat = {
msg: "",
status: PENDING,
};
try {
await gamedigMonitor.check(monitor, heartbeat, {});
assert.strictEqual(heartbeat.status, UP);
assert.strictEqual(heartbeat.msg, "Test Server");
assert.strictEqual(heartbeat.ping, 50);
} finally {
mock.restoreAll();
}
});
test("check() uses IP address directly without DNS resolution when hostname is IPv4", async () => {
const gamedigMonitor = new GameDigMonitorType();
let capturedOptions = null;
mock.method(Gamedig, "query", async (options) => {
capturedOptions = options;
return {
name: "Test Server",
ping: 30,
};
});
const monitor = {
hostname: "192.168.1.100",
port: 27015,
game: "valve",
gamedigGivenPortOnly: true,
};
const heartbeat = {
msg: "",
status: PENDING,
};
try {
await gamedigMonitor.check(monitor, heartbeat, {});
assert.strictEqual(capturedOptions.host, "192.168.1.100");
assert.strictEqual(heartbeat.status, UP);
} finally {
mock.restoreAll();
}
});
test("check() uses IP address directly without DNS resolution when hostname is IPv6", async () => {
const gamedigMonitor = new GameDigMonitorType();
let capturedOptions = null;
mock.method(Gamedig, "query", async (options) => {
capturedOptions = options;
return {
name: "Test Server",
ping: 30,
};
});
const monitor = {
hostname: "::1",
port: 27015,
game: "valve",
gamedigGivenPortOnly: true,
};
const heartbeat = {
msg: "",
status: PENDING,
};
try {
await gamedigMonitor.check(monitor, heartbeat, {});
assert.strictEqual(capturedOptions.host, "::1");
assert.strictEqual(heartbeat.status, UP);
} finally {
mock.restoreAll();
}
});
test("check() passes correct parameters to Gamedig.query", async () => {
const gamedigMonitor = new GameDigMonitorType();
let capturedOptions = null;
mock.method(Gamedig, "query", async (options) => {
capturedOptions = options;
return {
name: "Test Server",
ping: 25,
};
});
const monitor = {
hostname: "192.168.1.100",
port: 27015,
game: "valve",
gamedigGivenPortOnly: true,
};
const heartbeat = {
msg: "",
status: PENDING,
};
try {
await gamedigMonitor.check(monitor, heartbeat, {});
assert.strictEqual(capturedOptions.type, "valve");
assert.strictEqual(capturedOptions.host, "192.168.1.100");
assert.strictEqual(capturedOptions.port, 27015);
assert.strictEqual(capturedOptions.givenPortOnly, true);
} finally {
mock.restoreAll();
}
});
test("check() converts gamedigGivenPortOnly to boolean when value is truthy non-boolean", async () => {
const gamedigMonitor = new GameDigMonitorType();
let capturedOptions = null;
mock.method(Gamedig, "query", async (options) => {
capturedOptions = options;
return {
name: "Test Server",
ping: 30,
};
});
const monitor = {
hostname: "127.0.0.1",
port: 25565,
game: "minecraft",
gamedigGivenPortOnly: 1,
};
const heartbeat = {
msg: "",
status: PENDING,
};
try {
await gamedigMonitor.check(monitor, heartbeat, {});
assert.strictEqual(capturedOptions.givenPortOnly, true);
assert.strictEqual(typeof capturedOptions.givenPortOnly, "boolean");
} finally {
mock.restoreAll();
}
});
test("check() sets status to DOWN and rejects when game server is unreachable", async () => {
const gamedigMonitor = new GameDigMonitorType();
const monitor = {
hostname: "127.0.0.1",
port: 54321,
game: "minecraft",
gamedigGivenPortOnly: true,
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
gamedigMonitor.check(monitor, heartbeat, {}),
/Error/
);
assert.strictEqual(heartbeat.status, DOWN);
});
test("resolveHostname() returns IP address when given valid hostname", async () => {
const gamedigMonitor = new GameDigMonitorType();
const resolvedIP = await gamedigMonitor.resolveHostname("localhost");
assert.ok(
net.isIP(resolvedIP) !== 0,
`Expected valid IP address, got ${resolvedIP}`
);
});
test("resolveHostname() rejects when DNS resolution fails for invalid hostname", async () => {
const gamedigMonitor = new GameDigMonitorType();
await assert.rejects(
gamedigMonitor.resolveHostname("this-domain-definitely-does-not-exist-12345.invalid"),
/DNS resolution failed/
);
});
});