uptime-kuma/test/backend-test/monitors/test-rabbitmq.js

const { describe, test } = require("node:test");
const assert = require("node:assert");
const { RabbitMQContainer } = require("@testcontainers/rabbitmq");
const { RabbitMqMonitorType } = require("../../../server/monitor-types/rabbitmq");
const { UP, PENDING } = require("../../../src/util");

describe(
    "RabbitMQ Single Node",
    {
        skip: !!process.env.CI && (process.platform !== "linux" || process.arch !== "x64"),
    },
    () => {
        test("check() sets status to UP when RabbitMQ server is reachable", async () => {
            // The default timeout of 30 seconds might not be enough for the container to start
            const rabbitMQContainer = await new RabbitMQContainer().withStartupTimeout(60000).start();
            const rabbitMQMonitor = new RabbitMqMonitorType();
            const connectionString = `http://${rabbitMQContainer.getHost()}:${rabbitMQContainer.getMappedPort(15672)}`;

            const monitor = {
                rabbitmqNodes: JSON.stringify([connectionString]),
                rabbitmqUsername: "guest",
                rabbitmqPassword: "guest",
                timeout: 10,
            };

            const heartbeat = {
                msg: "",
                status: PENDING,
            };

            try {
                await rabbitMQMonitor.check(monitor, heartbeat, {});
                assert.strictEqual(heartbeat.status, UP);
                assert.strictEqual(heartbeat.msg, "Node is reachable and there are no alerts in the cluster");
            } finally {
                rabbitMQContainer.stop();
            }
        });

        test("check() rejects when RabbitMQ server is not reachable", async () => {
            const rabbitMQMonitor = new RabbitMqMonitorType();
            const monitor = {
                rabbitmqNodes: JSON.stringify(["http://localhost:15672"]),
                rabbitmqUsername: "rabbitmqUser",
                rabbitmqPassword: "rabbitmqPass",
                timeout: 10,
            };

            const heartbeat = {
                msg: "",
                status: PENDING,
            };

            // regex match any string
            const regex = /.+/;

            await assert.rejects(rabbitMQMonitor.check(monitor, heartbeat, {}), regex);
        });

        test("checkSingleNode() succeeds when node is healthy", async () => {
            const rabbitMQContainer = await new RabbitMQContainer().withStartupTimeout(60000).start();
            const rabbitMQMonitor = new RabbitMqMonitorType();
            const connectionString = `http://${rabbitMQContainer.getHost()}:${rabbitMQContainer.getMappedPort(15672)}`;

            const monitor = {
                name: "Test Monitor",
                rabbitmqUsername: "guest",
                rabbitmqPassword: "guest",
                timeout: 10,
            };

            try {
                // Should not throw - just validates the node is healthy
                await rabbitMQMonitor.checkSingleNode(monitor, connectionString, "1/1");
            } finally {
                rabbitMQContainer.stop();
            }
        });

        test("checkSingleNode() throws error when node is unreachable", async () => {
            const rabbitMQMonitor = new RabbitMqMonitorType();
            const monitor = {
                name: "Test Monitor",
                rabbitmqUsername: "guest",
                rabbitmqPassword: "guest",
                timeout: 10,
            };

            // Should reject with any error (connection refused, timeout, etc.)
            await assert.rejects(rabbitMQMonitor.checkSingleNode(monitor, "http://localhost:15672", "1/1"), Error);
        });
    }
);

describe("RabbitMQ Multi-Node (Mocked)", () => {
    test("check() succeeds when first node is healthy", async () => {
        const rabbitMQMonitor = new RabbitMqMonitorType();
        const monitor = {
            rabbitmqNodes: JSON.stringify(["http://node1:15672", "http://node2:15672"]),
            rabbitmqUsername: "guest",
            rabbitmqPassword: "guest",
            timeout: 10,
        };

        const heartbeat = {
            msg: "",
            status: PENDING,
        };

        // Mock checkSingleNode to succeed on first call (just don't throw)
        let callCount = 0;
        rabbitMQMonitor.checkSingleNode = async (mon, url, nodeInfo) => {
            callCount++;
            // Success - don't throw
        };

        await rabbitMQMonitor.check(monitor, heartbeat, {});
        assert.strictEqual(heartbeat.status, UP);
        assert.strictEqual(heartbeat.msg, "One of the 2 nodes is reachable and there are no alerts in the cluster");
        assert.strictEqual(callCount, 1, "Should only check first node");
    });

    test("check() succeeds when second node is healthy after first fails", async () => {
        const rabbitMQMonitor = new RabbitMqMonitorType();
        const monitor = {
            rabbitmqNodes: JSON.stringify(["http://node1:15672", "http://node2:15672"]),
            rabbitmqUsername: "guest",
            rabbitmqPassword: "guest",
            timeout: 10,
        };

        const heartbeat = {
            msg: "",
            status: PENDING,
        };

        // Mock checkSingleNode to fail first, succeed second
        let callCount = 0;
        rabbitMQMonitor.checkSingleNode = async (mon, url, nodeInfo) => {
            callCount++;
            if (callCount === 1) {
                throw new Error("Node 1 connection failed");
            }
            // Second call succeeds - don't throw
        };

        await rabbitMQMonitor.check(monitor, heartbeat, {});
        assert.strictEqual(heartbeat.status, UP);
        assert.strictEqual(heartbeat.msg, "One of the 2 nodes is reachable and there are no alerts in the cluster");
        assert.strictEqual(callCount, 2, "Should check both nodes");
    });

    test("check() fails with consolidated error when all nodes are down", async () => {
        const rabbitMQMonitor = new RabbitMqMonitorType();
        const monitor = {
            rabbitmqNodes: JSON.stringify(["http://node1:15672", "http://node2:15672", "http://node3:15672"]),
            rabbitmqUsername: "guest",
            rabbitmqPassword: "guest",
            timeout: 10,
        };

        const heartbeat = {
            msg: "",
            status: PENDING,
        };

        // Mock checkSingleNode to always fail
        let callCount = 0;
        rabbitMQMonitor.checkSingleNode = async (mon, url, nodeInfo) => {
            callCount++;
            throw new Error(`Connection failed to node ${callCount}`);
        };

        await assert.rejects(rabbitMQMonitor.check(monitor, heartbeat, {}), (error) => {
            assert.match(error.message, /All 3 nodes failed/);
            assert.match(error.message, /Node 1:/);
            assert.match(error.message, /Node 2:/);
            assert.match(error.message, /Node 3:/);
            return true;
        });
        assert.strictEqual(callCount, 3, "Should check all three nodes");
    });

    test("check() fails when no nodes are configured", async () => {
        const rabbitMQMonitor = new RabbitMqMonitorType();
        const monitor = {
            rabbitmqNodes: JSON.stringify([]),
            rabbitmqUsername: "guest",
            rabbitmqPassword: "guest",
            timeout: 10,
        };

        const heartbeat = {
            msg: "",
            status: PENDING,
        };

        await assert.rejects(rabbitMQMonitor.check(monitor, heartbeat, {}), /No RabbitMQ nodes configured/);
    });

    test("check() tries all nodes before failing", async () => {
        const rabbitMQMonitor = new RabbitMqMonitorType();
        const monitor = {
            rabbitmqNodes: JSON.stringify([
                "http://node1:15672",
                "http://node2:15672",
                "http://node3:15672",
                "http://node4:15672",
            ]),
            rabbitmqUsername: "guest",
            rabbitmqPassword: "guest",
            timeout: 10,
        };

        const heartbeat = {
            msg: "",
            status: PENDING,
        };

        const checkedNodes = [];
        rabbitMQMonitor.checkSingleNode = async (mon, url, nodeInfo) => {
            checkedNodes.push(url);
            throw new Error(`Failed: ${url}`);
        };

        await assert.rejects(rabbitMQMonitor.check(monitor, heartbeat, {}), /All 4 nodes failed/);

        assert.strictEqual(checkedNodes.length, 4, "Should check all 4 nodes");
        assert.strictEqual(checkedNodes[0], "http://node1:15672");
        assert.strictEqual(checkedNodes[1], "http://node2:15672");
        assert.strictEqual(checkedNodes[2], "http://node3:15672");
        assert.strictEqual(checkedNodes[3], "http://node4:15672");
    });
});