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

Added systemd support to auto-test.yml

Browse Source
This commit is contained in:
iotux 2025-12-26 11:36:08 +01:00
parent 92abea01b5
commit 3b91e5d340
2 changed files with 130 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
.github/workflows/auto-test.yml vendored
View File

@ -33,6 +33,17 @@ jobs:
- run: git config --global core.autocrlf false # Mainly for Windows
- uses: actions/checkout@v4
# Detect if we need to run the Systemd specific tests
- name: Detect systemd monitor changes
id: systemd-files
uses: dorny/paths-filter@v3
with:
filters: |
systemd:
- 'server/monitor-types/system-service.js'
- 'test/backend-test/test-system-service.js'
- '.github/workflows/auto-test.yml'
- name: Cache/Restore node_modules
uses: actions/cache@v4
id: node-modules-cache
@ -51,6 +62,81 @@ jobs:
HEADLESS_TEST: 1
JUST_FOR_TEST: ${{ secrets.JUST_FOR_TEST }}
# Systemd container integration
# Runs ONLY on Linux AND if systemd-related files have changed.
- name: Build Systemd Docker Image (Linux Only)
if: runner.os == 'Linux' && steps.systemd-files.outputs.systemd == 'true'
env:
NODE_MAJOR: ${{ matrix.node }}
run: |
cat <<EOF > Dockerfile.systemd
FROM ubuntu:22.04
ENV DEBIAN_FRONTEND=noninteractive
# Install systemd and dependencies
RUN apt-get update && \
apt-get install -y systemd systemd-sysv dbus curl gnupg build-essential python3 make g++ ca-certificates
# Install the specific Node.js version from the matrix
RUN mkdir -p /etc/apt/keyrings && \
curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg && \
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_${NODE_MAJOR}.x nodistro main" | tee /etc/apt/sources.list.d/nodesource.list && \
apt-get update && \
apt-get install -y nodejs
CMD ["/sbin/init"]
EOF
docker build -t kuma-systemd-image -f Dockerfile.systemd .
- name: Start Systemd Container
if: runner.os == 'Linux' && steps.systemd-files.outputs.systemd == 'true'
run: |
docker rm -f kuma-systemd 2>/dev/null || true
# Start with critical flags for systemd compatibility on GitHub Runners
docker run --privileged --detach --name kuma-systemd \
--env container=docker \
--cgroupns=host \
--security-opt seccomp=unconfined \
--security-opt apparmor=unconfined \
--tmpfs /run --tmpfs /run/lock \
-v /sys/fs/cgroup:/sys/fs/cgroup:rw \
-v "$PWD":/workspace \
-w /workspace \
kuma-systemd-image
echo "⏳ Waiting 5 seconds for systemd boot..."
sleep 5
# Verification check
if [ "$(docker inspect -f '{{.State.Running}}' kuma-systemd)" != "true" ]; then
echo "❌ Container crashed. Logs:"
docker logs kuma-systemd
exit 1
fi
- name: Run Systemd Test (Inside Container)
if: runner.os == 'Linux' && steps.systemd-files.outputs.systemd == 'true'
env:
HEADLESS_TEST: 1
JUST_FOR_TEST: ${{ secrets.JUST_FOR_TEST }}
run: |
# Ensure deps are ready inside container
docker exec kuma-systemd npm install
docker exec kuma-systemd npm run build
echo "🧪 Running ONLY the System Service test file..."
# We run strictly the specific test file using Node's native test runner
docker exec -e HEADLESS_TEST=1 kuma-systemd node --test test/backend-test/test-system-service.js
- name: Cleanup Systemd Container
if: ${{ always() && runner.os == 'Linux' && steps.systemd-files.outputs.systemd == 'true' }}
run: |
docker rm -f kuma-systemd
rm -f Dockerfile.systemd
# As a lot of dev dependencies are not supported on ARMv7, we have to test it separately and just test if `npm ci --production` works
armv7-simple-test:
needs: [ e2e-test ]
@ -127,4 +213,4 @@ jobs:
run: npx playwright@${{ env.PLAYWRIGHT_VERSION }} install
- run: npm run build
- run: npm run test-e2e
- run: npm run test-e2e

107
test/backend-test/test-system-service.js
View File

@ -3,15 +3,35 @@ const assert = require("node:assert");
const { SystemServiceMonitorType } = require("../../server/monitor-types/system-service");
const { DOWN, UP } = require("../../src/util");
const process = require("process");
const fs = require("fs");
const path = require("path");
const os = require("os");
const { execSync } = require("child_process");
// GUARD CLAUSE: Skip test if not on Systemd (Linux) or Windows
let shouldRun = false;
if (process.platform === "win32") {
shouldRun = true;
} else if (process.platform === "linux") {
try {
// Check if PID 1 is systemd (or init which maps to systemd in our container)
const pid1Comm = execSync("ps -p 1 -o comm=", { encoding: "utf-8" }).trim();
if (pid1Comm === "systemd" || pid1Comm === "init") {
shouldRun = true;
}
} catch (e) {
// Command failed, likely not systemd
}
}
if (!shouldRun) {
console.log("⚠️ Skipping System Service test: Environment does not support systemd/services.");
// We return early or just don't define tests, so the runner sees 0 failures.
// In node:test, we can just exit gracefully or simply not call 'test()'.
process.exit(0);
}
describe("SystemServiceMonitorType", () => {
let monitorType;
let heartbeat;
let tempDir;
let originalPath;
let originalPlatform;
beforeEach(() => {
@ -20,65 +40,32 @@ describe("SystemServiceMonitorType", () => {
status: DOWN,
msg: "",
};
originalPath = process.env.PATH;
originalPlatform = Object.getOwnPropertyDescriptor(process, "platform");
});
afterEach(() => {
process.env.PATH = originalPath;
if (originalPlatform) {
Object.defineProperty(process, "platform", originalPlatform);
}
if (tempDir && fs.existsSync(tempDir)) {
try {
fs.rmSync(tempDir, {
recursive: true,
force: true,
});
} catch (e) {
// Ignore cleanup errors
}
}
});
/**
* Helper to create a fake executable that prints specific output.
* @param {string} baseName The name of the executable (e.g. systemctl)
* @param {string} outputText The text to echo to stdout
* @param {number} exitCode The exit code
* @returns {void}
*/
function createMockCommand(baseName, outputText, exitCode = 0) {
tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "uptime-kuma-test-"));
it("should detect a running service", async (t) => {
// Requirement: Use REAL system tools (no mocks).
// Therefore, we must skip this test on platforms that lack systemd/PowerShell (like macOS).
if (process.platform !== "linux" && process.platform !== "win32") {
t.skip("Skipping integration test: Real systemd/PowerShell not available on this platform");
return;
}
// Only needed for non-Windows mocks (Linux/Mac)
const content = `#!/bin/sh\necho "${outputText}"\nexit ${exitCode}`;
const scriptPath = path.join(tempDir, baseName);
fs.writeFileSync(scriptPath, content);
fs.chmodSync(scriptPath, 0o755);
process.env.PATH = tempDir + path.delimiter + process.env.PATH;
}
it("should detect a running service", async () => {
const isWin = process.platform === "win32";
let serviceName = "myservice";
if (isWin) {
// Windows CI has real PowerShell and real services.
// We test against 'Dnscache', a core service guaranteed to be running.
// Windows: Test against 'Dnscache' (DNS Client), guaranteed to be running.
serviceName = "Dnscache";
} else {
// Linux CI (Docker) lacks systemd. We must mock the tool to pass the test.
createMockCommand("systemctl", "active", 0);
}
// If on macOS, mock Linux platform so the code tries to use systemctl
if (process.platform === "darwin") {
Object.defineProperty(process, "platform", {
value: "linux",
configurable: true,
});
// Linux: Test against 'systemd-journald', a core service of systemd.
serviceName = "systemd-journald";
}
const monitor = {
@ -91,24 +78,15 @@ describe("SystemServiceMonitorType", () => {
assert.ok(heartbeat.msg.includes("is running"));
});
it("should detect a stopped service", async () => {
const isWin = process.platform === "win32";
let serviceName = "myservice";
if (isWin) {
// Real Windows: Query a non-existent service to force an error/down state
serviceName = "non-existent-service-12345";
} else {
// Mocked Linux: Create a mock that returns "inactive" (exit code 1)
createMockCommand("systemctl", "inactive", 1);
it("should detect a stopped service", async (t) => {
if (process.platform !== "linux" && process.platform !== "win32") {
t.skip("Skipping integration test: Real systemd/PowerShell not available on this platform");
return;
}
if (process.platform === "darwin") {
Object.defineProperty(process, "platform", {
value: "linux",
configurable: true,
});
}
// Query a non-existent service to force an error/down state.
// This works correctly on both 'systemctl' and 'Get-Service'.
const serviceName = "non-existent-service-12345";
const monitor = {
system_service_name: serviceName,
@ -143,6 +121,7 @@ describe("SystemServiceMonitorType", () => {
});
it("should throw error on unsupported platforms", async () => {
// This test mocks the platform, so it can run anywhere.
Object.defineProperty(process, "platform", {
value: "darwin",
configurable: true,