viscous/uptime-kuma
1
0
Fork 0
mirror of https://github.com/louislam/uptime-kuma.git synced 2026-03-03 02:37:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' into security/improved-security

Browse Source
This commit is contained in:
Julian Speckmann
2026-01-02 04:29:06 +01:00
committed by GitHub
parent 7c594d1c05 7e557db5f9
commit 4ee7fb208d
46 changed files with 2484 additions and 1878 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
.github/dependabot.yml vendored Normal file
View File

@@ -0,0 +1,22 @@
# Dependabot configuration for Uptime Kuma
# See: https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file
version: 2
updates:
# Enable version updates for GitHub Actions
- package-ecosystem: "github-actions"
directory: "/"
schedule:
interval: "weekly"
day: "monday"
# Group all GitHub Actions updates into a single PR
groups:
github-actions:
patterns:
- "*"
open-pull-requests-limit: 5
commit-message:
prefix: "chore"
include: "scope"
cooldown:
default-days: 7

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

@@ -12,12 +12,15 @@ on:
branches: [ master, 1.23.X ]
paths-ignore:
- '*.md'
permissions: {}
jobs:
auto-test:
needs: [ e2e-test ]
runs-on: ${{ matrix.os }}
timeout-minutes: 15
permissions:
contents: read
strategy:
matrix:
@@ -31,17 +34,18 @@ jobs:
steps:
- run: git config --global core.autocrlf false # Mainly for Windows
- uses: actions/checkout@v4
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
with: { persist-credentials: false }
- name: Cache/Restore node_modules
uses: actions/cache@v4
uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
id: node-modules-cache
with:
path: node_modules
key: node-modules-${{ runner.os }}-${{ hashFiles('**/package-lock.json') }}
- name: Use Node.js ${{ matrix.node }}
uses: actions/setup-node@v6
uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
with:
node-version: ${{ matrix.node }}
- run: npm install
@@ -56,6 +60,8 @@ jobs:
needs: [ e2e-test ]
runs-on: ${{ matrix.os }}
timeout-minutes: 15
permissions:
contents: read
if: ${{ github.repository == 'louislam/uptime-kuma' }}
strategy:
matrix:
@@ -65,37 +71,41 @@ jobs:
steps:
- run: git config --global core.autocrlf false # Mainly for Windows
- uses: actions/checkout@v4
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
with: { persist-credentials: false }
- name: Cache/Restore node_modules
uses: actions/cache@v4
uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
id: node-modules-cache
with:
path: node_modules
key: node-modules-${{ runner.os }}-${{ hashFiles('**/package-lock.json') }}
- name: Use Node.js ${{ matrix.node }}
uses: actions/setup-node@v6
uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
with:
node-version: ${{ matrix.node }}
- run: npm install --production
check-linters:
runs-on: ubuntu-latest
permissions:
contents: read
steps:
- run: git config --global core.autocrlf false # Mainly for Windows
- uses: actions/checkout@v4
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
with: { persist-credentials: false }
- name: Cache/Restore node_modules
uses: actions/cache@v4
uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
id: node-modules-cache
with:
path: node_modules
key: node-modules-${{ runner.os }}-${{ hashFiles('**/package-lock.json') }}
- name: Use Node.js 20
uses: actions/setup-node@v6
uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
with:
node-version: 20
- run: npm install
@@ -104,21 +114,24 @@ jobs:
e2e-test:
needs: [ check-linters ]
runs-on: ARM64
permissions:
contents: read
env:
PLAYWRIGHT_VERSION: ~1.39.0
steps:
- run: git config --global core.autocrlf false # Mainly for Windows
- uses: actions/checkout@v4
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
with: { persist-credentials: false }
- name: Cache/Restore node_modules
uses: actions/cache@v4
uses: actions/cache@9255dc7a253b0ccc959486e2bca901246202afeb # v5.0.1
id: node-modules-cache
with:
path: node_modules
key: node-modules-${{ runner.os }}-${{ hashFiles('**/package-lock.json') }}
- name: Setup Node.js
uses: actions/setup-node@v6
uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
with:
node-version: 22
- run: npm install

13
.github/workflows/close-incorrect-issue.yml vendored
View File

@@ -3,10 +3,13 @@ name: Close Incorrect Issue
on:
issues:
types: [opened]
permissions: {}
jobs:
close-incorrect-issue:
runs-on: ${{ matrix.os }}
permissions:
issues: write
strategy:
matrix:
@@ -14,11 +17,15 @@ jobs:
node-version: [20]
steps:
- uses: actions/checkout@v4
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
with: { persist-credentials: false }
- name: Use Node.js ${{ matrix.node-version }}
uses: actions/setup-node@v6
uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
with:
node-version: ${{ matrix.node-version }}
- run: npm ci
- run: node extra/close-incorrect-issue.js ${{ secrets.GITHUB_TOKEN }} ${{ github.event.issue.number }} ${{ github.event.issue.user.login }}
- name: Close incorrect issue
run: node extra/close-incorrect-issue.js ${{ secrets.GITHUB_TOKEN }} ${{ github.event.issue.number }} "$ISSUE_USER_LOGIN"
env:
ISSUE_USER_LOGIN: ${{ github.event.issue.user.login }}

10
.github/workflows/codeql-analysis.yml vendored
View File

@@ -25,19 +25,19 @@ jobs:
language: [ 'go', 'javascript-typescript' ]
steps:
- name: Checkout repository
uses: actions/checkout@v3
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
with: { persist-credentials: false }
# Initializes the CodeQL tools for scanning.
- name: Initialize CodeQL
uses: github/codeql-action/init@v2
uses: github/codeql-action/init@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
with:
languages: ${{ matrix.language }}
- name: Autobuild
uses: github/codeql-action/autobuild@v2
uses: github/codeql-action/autobuild@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
- name: Perform CodeQL Analysis
uses: github/codeql-action/analyze@v2
uses: github/codeql-action/analyze@5d4e8d1aca955e8d8589aabd499c5cae939e33c7 # v4.31.9
with:
category: "/language:${{matrix.language}}"

9
.github/workflows/conflict_labeler.yml vendored
View File

@@ -1,6 +1,11 @@
name: Merge Conflict Labeler
on:
# pull_request_target is safe here because:
# 1. Only uses a pinned trusted action (by SHA)
# 2. Has minimal permissions (contents: read, pull-requests: write)
# 3. Doesn't checkout or execute any untrusted code from PRs
# 4. Only adds/removes labels based on merge conflict status
on: # zizmor: ignore[dangerous-triggers]
push:
branches:
- master
@@ -19,7 +24,7 @@ jobs:
pull-requests: write
steps:
- name: Apply label
uses: eps1lon/actions-label-merge-conflict@v3
uses: eps1lon/actions-label-merge-conflict@1df065ebe6e3310545d4f4c4e862e43bdca146f0 # v3.0.3
with:
dirtyLabel: 'needs:resolve-merge-conflict'
repoToken: '${{ secrets.GITHUB_TOKEN }}'

5
.github/workflows/prevent-file-change.yml vendored
View File

@@ -2,13 +2,16 @@ name: prevent-file-change
on:
pull_request:
permissions: {}
jobs:
check-file-changes:
runs-on: ubuntu-latest
permissions:
pull-requests: read
steps:
- name: Prevent file change
uses: xalvarez/prevent-file-change-action@v1
uses: xalvarez/prevent-file-change-action@004d9f17c2e4a7afa037cda5f38dc55a5e9c9c06 # v1.9.1
with:
githubToken: ${{ secrets.GITHUB_TOKEN }}
# Regex, /src/lang/*.json is not allowed to be changed, except for /src/lang/en.json

10
.github/workflows/stale-bot.yml vendored
View File

@@ -4,12 +4,16 @@ on:
schedule:
- cron: '0 */6 * * *'
#Run every 6 hours
permissions: {}
jobs:
stale:
runs-on: ubuntu-latest
permissions:
actions: write
issues: write
steps:
- uses: actions/stale@v9
- uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
with:
stale-issue-message: |-
We are clearing up our old `help`-issues and your issue has been open for 60 days with no activity.
@@ -18,10 +22,10 @@ jobs:
days-before-close: 7
days-before-pr-stale: -1
days-before-pr-close: -1
exempt-issue-labels: 'News,Medium,High,discussion,bug,doc,feature-request'
exempt-issue-labels: 'News,discussion,bug,doc,feature-request'
exempt-issue-assignees: 'louislam'
operations-per-run: 200
- uses: actions/stale@v9
- uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10.1.1
with:
stale-issue-message: |-
This issue was marked as `cannot-reproduce` by a maintainer.

20
.github/workflows/validate.yml vendored
View File

@@ -8,20 +8,21 @@ on:
- master
- 1.23.X
workflow_dispatch:
permissions:
contents: read
pull-requests: write # enable write permissions for pull request comments
permissions: {}
jobs:
json-yaml-validate:
runs-on: ubuntu-latest
permissions:
contents: read
pull-requests: write # enable write permissions for pull request comments
steps:
- uses: actions/checkout@v4
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
with: { persist-credentials: false }
- name: json-yaml-validate
id: json-yaml-validate
uses: GrantBirki/json-yaml-validate@v2.4.0
uses: GrantBirki/json-yaml-validate@9bbaa8474e3af4e91f25eda8ac194fdc30564d96 # v4.0.0
with:
comment: "true" # enable comment mode
exclude_file: ".github/config/exclude.txt" # gitignore style file for exclusions
@@ -29,10 +30,13 @@ jobs:
# General validations
validate:
runs-on: ubuntu-latest
permissions:
contents: read
steps:
- uses: actions/checkout@v4
- uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
with: { persist-credentials: false }
- name: Use Node.js 20
uses: actions/setup-node@v6
uses: actions/setup-node@395ad3262231945c25e8478fd5baf05154b1d79f # v6.1.0
with:
node-version: 20

30
db/knex_migrations/2025-12-29-0000-remove-line-notify.js Normal file
View File

@@ -0,0 +1,30 @@
exports.up = async function (knex) {
const notifications = await knex("notification").select("id", "config");
const lineNotifyIDs = [];
for (const { id, config } of notifications) {
try {
const parsedConfig = JSON.parse(config || "{}");
const type = typeof parsedConfig.type === "string" ? parsedConfig.type.toLowerCase() : "";
if (type === "linenotify" || type === "line-notify") {
lineNotifyIDs.push(id);
}
} catch (error) {
// Ignore invalid JSON blobs here; they are handled elsewhere in the app.
}
}
if (lineNotifyIDs.length === 0) {
return;
}
await knex.transaction(async (trx) => {
await trx("monitor_notification").whereIn("notification_id", lineNotifyIDs).del();
await trx("notification").whereIn("id", lineNotifyIDs).del();
});
};
exports.down = async function () {
// Removal of LINE Notify configs is not reversible.
};

1476
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

5
package.json
View File

@@ -116,14 +116,14 @@
"mitt": "~3.0.1",
"mongodb": "~4.17.1",
"mqtt": "~4.3.7",
"mssql": "~11.0.0",
"mssql": "~12.0.0",
"mysql2": "~3.11.3",
"nanoid": "~3.3.4",
"net-snmp": "^3.11.2",
"node-cloudflared-tunnel": "~1.0.9",
"node-radius-utils": "~1.2.0",
"node-fetch-cache": "^5.1.0",
"nodemailer": "~7.0.12",
"node-radius-utils": "~1.2.0",
"nostr-tools": "^2.10.4",
"notp": "~2.0.3",
"openid-client": "^5.4.2",
@@ -161,6 +161,7 @@
"@playwright/test": "~1.39.0",
"@popperjs/core": "~2.10.2",
"@testcontainers/hivemq": "^10.13.1",
"@testcontainers/mssqlserver": "^10.28.0",
"@testcontainers/postgresql": "^11.9.0",
"@testcontainers/rabbitmq": "^10.13.2",
"@types/bootstrap": "~5.1.9",

4
server/model/domain_expiry.js
View File

@@ -172,9 +172,9 @@ class DomainExpiry extends BeanModel {
}
/**
* @returns {(Date|null)} Expiry date from RDAP
* @returns {Promise<(Date|null)>} Expiry date from RDAP
*/
getExpiryDate() {
async getExpiryDate() {
return getRdapDomainExpiryDate(this.domain);
}

10
server/model/monitor.js
View File

@@ -8,7 +8,7 @@ const { log, UP, DOWN, PENDING, MAINTENANCE, flipStatus, MAX_INTERVAL_SECOND, MI
PING_COUNT_MIN, PING_COUNT_MAX, PING_COUNT_DEFAULT,
PING_PER_REQUEST_TIMEOUT_MIN, PING_PER_REQUEST_TIMEOUT_MAX, PING_PER_REQUEST_TIMEOUT_DEFAULT
} = require("../../src/util");
const { ping, checkCertificate, checkStatusCode, getTotalClientInRoom, setting, mssqlQuery, mysqlQuery, setSetting, httpNtlm, radius,
const { ping, checkCertificate, checkStatusCode, getTotalClientInRoom, setting, mysqlQuery, setSetting, httpNtlm, radius,
kafkaProducerAsync, getOidcTokenClientCredentials, rootCertificatesFingerprints, axiosAbortSignal, checkCertificateHostname
} = require("../util-server");
const { R } = require("redbean-node");
@@ -782,14 +782,6 @@ class Monitor extends BeanModel {
} else {
throw Error("Container State is " + res.data.State.Status);
}
} else if (this.type === "sqlserver") {
let startTime = dayjs().valueOf();
await mssqlQuery(this.databaseConnectionString, this.databaseQuery || "SELECT 1");
bean.msg = "";
bean.status = UP;
bean.ping = dayjs().valueOf() - startTime;
} else if (this.type === "mysql") {
let startTime = dayjs().valueOf();

118
server/monitor-types/mssql.js Normal file
View File

@@ -0,0 +1,118 @@
const { MonitorType } = require("./monitor-type");
const { log, UP } = require("../../src/util");
const dayjs = require("dayjs");
const mssql = require("mssql");
const { ConditionVariable } = require("../monitor-conditions/variables");
const { defaultStringOperators } = require("../monitor-conditions/operators");
const {
ConditionExpressionGroup,
} = require("../monitor-conditions/expression");
const { evaluateExpressionGroup } = require("../monitor-conditions/evaluator");
class MssqlMonitorType extends MonitorType {
name = "sqlserver";
supportsConditions = true;
conditionVariables = [
new ConditionVariable("result", defaultStringOperators),
];
/**
* @inheritdoc
*/
async check(monitor, heartbeat, _server) {
let startTime = dayjs().valueOf();
let query = monitor.databaseQuery;
// No query provided by user, use SELECT 1
if (!query || (typeof query === "string" && query.trim() === "")) {
query = "SELECT 1";
}
let result;
try {
result = await this.mssqlQuery(
monitor.databaseConnectionString,
query
);
} catch (error) {
log.error("sqlserver", "Database query failed:", error.message);
throw new Error(
`Database connection/query failed: ${error.message}`
);
} finally {
heartbeat.ping = dayjs().valueOf() - startTime;
}
const conditions = ConditionExpressionGroup.fromMonitor(monitor);
const handleConditions = (data) =>
conditions ? evaluateExpressionGroup(conditions, data) : true;
// Since result is now a single value, pass it directly to conditions
const conditionsResult = handleConditions({ result: String(result) });
if (!conditionsResult) {
throw new Error(
`Query result did not meet the specified conditions (${result})`
);
}
heartbeat.msg = "";
heartbeat.status = UP;
}
/**
* Run a query on MSSQL server
* @param {string} connectionString The database connection string
* @param {string} query The query to validate the database with
* @returns {Promise<any>} Single value from the first column of the first row
*/
async mssqlQuery(connectionString, query) {
let pool;
try {
pool = new mssql.ConnectionPool(connectionString);
await pool.connect();
const result = await pool.request().query(query);
// Check if we have results
if (!result.recordset || result.recordset.length === 0) {
throw new Error("Query returned no results");
}
// Check if we have multiple rows
if (result.recordset.length > 1) {
throw new Error(
"Multiple values were found, expected only one value"
);
}
const firstRow = result.recordset[0];
const columnNames = Object.keys(firstRow);
// Check if we have multiple columns
if (columnNames.length > 1) {
throw new Error(
"Multiple columns were found, expected only one value"
);
}
// Return the single value from the first (and only) column
return firstRow[columnNames[0]];
} catch (err) {
log.debug(
"sqlserver",
"Error caught in the query execution.",
err.message
);
throw err;
} finally {
if (pool) {
await pool.close();
}
}
}
}
module.exports = {
MssqlMonitorType,
};

60
server/monitor-types/websocket-upgrade.js
View File

@@ -1,6 +1,26 @@
const { MonitorType } = require("./monitor-type");
const WebSocket = require("ws");
const { UP } = require("../../src/util");
const { checkStatusCode } = require("../util-server");
// Define closing error codes https://www.iana.org/assignments/websocket/websocket.xml#close-code-number
const WS_ERR_CODE = {
1002: "Protocol error",
1003: "Unsupported Data",
1005: "No Status Received",
1006: "Abnormal Closure",
1007: "Invalid frame payload data",
1008: "Policy Violation",
1009: "Message Too Big",
1010: "Mandatory Extension Missing",
1011: "Internal Error",
1012: "Service Restart",
1013: "Try Again Later",
1014: "Bad Gateway",
1015: "TLS Handshake Failed",
3000: "Unauthorized",
3003: "Forbidden",
3008: "Timeout",
};
class WebSocketMonitorType extends MonitorType {
name = "websocket-upgrade";
@@ -11,24 +31,36 @@ class WebSocketMonitorType extends MonitorType {
async check(monitor, heartbeat, _server) {
const [ message, code ] = await this.attemptUpgrade(monitor);
if (code === 1000) {
heartbeat.status = UP;
heartbeat.msg = message;
} else {
throw new Error(message);
if (typeof code !== "undefined") {
// If returned status code matches user controlled accepted status code(default 1000), return success
if (checkStatusCode(code, JSON.parse(monitor.accepted_statuscodes_json))) {
heartbeat.status = UP;
heartbeat.msg = message;
return; // success at this point
}
// Throw an error using friendly name if defined, fallback to generic msg
throw new Error(WS_ERR_CODE[code] || `Unexpected status code: ${code}`);
}
// If no close code, then an error has occurred, display to user
if (typeof message !== "undefined") {
throw new Error(`${message}`);
}
// Throw generic error if nothing is defined, should never happen
throw new Error("Unknown Websocket Error");
}
/**
* Uses the builtin Websocket API to establish a connection to target server
* Uses the ws Node.js library to establish a connection to target server
* @param {object} monitor The monitor object for input parameters.
* @returns {[ string, int ]} Array containing a status message and response code
*/
async attemptUpgrade(monitor) {
return new Promise((resolve) => {
let ws;
//If user selected a subprotocol, sets Sec-WebSocket-Protocol header. Subprotocol Identifier column: https://www.iana.org/assignments/websocket/websocket.xml#subprotocol-name
ws = monitor.wsSubprotocol === "" ? new WebSocket(monitor.url) : new WebSocket(monitor.url, monitor.wsSubprotocol);
const timeoutMs = (monitor.timeout ?? 20) * 1000;
// If user inputs subprotocol(s), convert to array, set Sec-WebSocket-Protocol header, timeout in ms. Subprotocol Identifier column: https://www.iana.org/assignments/websocket/websocket.xml#subprotocol-name
const subprotocol = monitor.wsSubprotocol ? monitor.wsSubprotocol.replace(/\s/g, "").split(",") : undefined;
const ws = new WebSocket(monitor.url, subprotocol, { handshakeTimeout: timeoutMs });
ws.addEventListener("open", (event) => {
// Immediately close the connection
@@ -36,17 +68,19 @@ class WebSocketMonitorType extends MonitorType {
});
ws.onerror = (error) => {
// Give user the choice to ignore Sec-WebSocket-Accept header
// Give user the choice to ignore Sec-WebSocket-Accept header for non compliant servers
// Header in HTTP 101 Switching Protocols response from server, technically already upgraded to WS
if (monitor.wsIgnoreSecWebsocketAcceptHeader && error.message === "Invalid Sec-WebSocket-Accept header") {
resolve([ "101 - OK", 1000 ]);
resolve([ "1000 - OK", 1000 ]);
return;
}
// Upgrade failed, return message to user
resolve([ error.message, error.code ]);
};
ws.onclose = (event) => {
// Upgrade success, connection closed successfully
resolve([ "101 - OK", event.code ]);
// Return the close code, if connection didn't close cleanly, return the reason if present
resolve([ event.wasClean ? event.code.toString() + " - OK" : event.reason, event.code ]);
};
});
}

53
server/notification-providers/linenotify.js
View File

@@ -1,53 +0,0 @@
const NotificationProvider = require("./notification-provider");
const axios = require("axios");
const qs = require("qs");
const { DOWN, UP } = require("../../src/util");
class LineNotify extends NotificationProvider {
name = "LineNotify";
/**
* @inheritdoc
*/
async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
const okMsg = "Sent Successfully.";
const url = "https://notify-api.line.me/api/notify";
try {
let config = {
headers: {
"Content-Type": "application/x-www-form-urlencoded",
"Authorization": "Bearer " + notification.lineNotifyAccessToken
}
};
config = this.getAxiosConfigWithProxy(config);
if (heartbeatJSON == null) {
let testMessage = {
"message": msg,
};
await axios.post(url, qs.stringify(testMessage), config);
} else if (heartbeatJSON["status"] === DOWN) {
let downMessage = {
"message": "\n[🔴 Down]\n" +
"Name: " + monitorJSON["name"] + " \n" +
heartbeatJSON["msg"] + "\n" +
`Time (${heartbeatJSON["timezone"]}): ${heartbeatJSON["localDateTime"]}`
};
await axios.post(url, qs.stringify(downMessage), config);
} else if (heartbeatJSON["status"] === UP) {
let upMessage = {
"message": "\n[✅ Up]\n" +
"Name: " + monitorJSON["name"] + " \n" +
heartbeatJSON["msg"] + "\n" +
`Time (${heartbeatJSON["timezone"]}): ${heartbeatJSON["localDateTime"]}`
};
await axios.post(url, qs.stringify(upMessage), config);
}
return okMsg;
} catch (error) {
this.throwGeneralAxiosError(error);
}
}
}
module.exports = LineNotify;

48
server/notification-providers/resend.js Normal file
View File

@@ -0,0 +1,48 @@
const NotificationProvider = require("./notification-provider");
const axios = require("axios");
class Resend extends NotificationProvider {
name = "Resend";
/**
* @inheritdoc
*/
async send(notification, msg, monitorJSON = null, heartbeatJSON = null) {
const okMsg = "Sent Successfully.";
try {
let config = {
headers: {
Authorization: `Bearer ${notification.resendApiKey}`,
"Content-Type": "application/json",
},
};
config = this.getAxiosConfigWithProxy(config);
const email = notification.resendFromEmail.trim();
const fromName = notification.resendFromName?.trim() || "Uptime Kuma";
let data = {
from: `${fromName} <${email}>`,
to: notification.resendToEmail,
subject: notification.resendSubject || "Notification from Your Uptime Kuma",
// supplied text directly instead of html
text: msg,
};
let result = await axios.post(
"https://api.resend.com/emails",
data,
config
);
if (result.status === 200) {
return okMsg;
} else {
throw new Error(`Unexpected status code: ${result.status}`);
}
} catch (error) {
this.throwGeneralAxiosError(error);
}
}
}
module.exports = Resend;

4
server/notification.js
View File

@@ -25,7 +25,6 @@ const HeiiOnCall = require("./notification-providers/heii-oncall");
const Keep = require("./notification-providers/keep");
const Kook = require("./notification-providers/kook");
const Line = require("./notification-providers/line");
const LineNotify = require("./notification-providers/linenotify");
const LunaSea = require("./notification-providers/lunasea");
const Matrix = require("./notification-providers/matrix");
const Mattermost = require("./notification-providers/mattermost");
@@ -78,6 +77,7 @@ const Onesender = require("./notification-providers/onesender");
const Wpush = require("./notification-providers/wpush");
const SendGrid = require("./notification-providers/send-grid");
const Brevo = require("./notification-providers/brevo");
const Resend = require("./notification-providers/resend");
const YZJ = require("./notification-providers/yzj");
const SMSPlanet = require("./notification-providers/sms-planet");
const SpugPush = require("./notification-providers/spugpush");
@@ -124,7 +124,6 @@ class Notification {
new Keep(),
new Kook(),
new Line(),
new LineNotify(),
new LunaSea(),
new Matrix(),
new Mattermost(),
@@ -176,6 +175,7 @@ class Notification {
new Cellsynt(),
new Wpush(),
new Brevo(),
new Resend(),
new YZJ(),
new SMSPlanet(),
new SpugPush(),

2
server/uptime-kuma-server.js
View File

@@ -124,6 +124,7 @@ class UptimeKumaServer {
UptimeKumaServer.monitorTypeList["port"] = new TCPMonitorType();
UptimeKumaServer.monitorTypeList["manual"] = new ManualMonitorType();
UptimeKumaServer.monitorTypeList["redis"] = new RedisMonitorType();
UptimeKumaServer.monitorTypeList["sqlserver"] = new MssqlMonitorType();
// Allow all CORS origins (polling) in development
let cors = undefined;
@@ -572,5 +573,6 @@ const { RabbitMqMonitorType } = require("./monitor-types/rabbitmq");
const { TCPMonitorType } = require("./monitor-types/tcp.js");
const { ManualMonitorType } = require("./monitor-types/manual");
const { RedisMonitorType } = require("./monitor-types/redis");
const { MssqlMonitorType } = require("./monitor-types/mssql");
const Monitor = require("./model/monitor");

26
server/util-server.js
View File

@@ -10,7 +10,6 @@ const { Resolver } = require("dns");
const iconv = require("iconv-lite");
const chardet = require("chardet");
const chroma = require("chroma-js");
const mssql = require("mssql");
const mysql = require("mysql2");
const { NtlmClient } = require("./modules/axios-ntlm/lib/ntlmClient.js");
const { Settings } = require("./settings");
@@ -322,31 +321,6 @@ exports.dnsResolve = function (hostname, resolverServer, resolverPort, rrtype) {
});
};
/**
* Run a query on SQL Server
* @param {string} connectionString The database connection string
* @param {string} query The query to validate the database with
* @returns {Promise<(string[] | object[] | object)>} Response from
* server
*/
exports.mssqlQuery = async function (connectionString, query) {
let pool;
try {
pool = new mssql.ConnectionPool(connectionString);
await pool.connect();
if (!query) {
query = "SELECT 1";
}
await pool.request().query(query);
pool.close();
} catch (e) {
if (pool) {
pool.close();
}
throw e;
}
};
/**
* Run a query on MySQL/MariaDB
* @param {string} connectionString The database connection string

2
src/assets/localization.scss
View File

@@ -1,6 +1,6 @@
html[lang='fa'] {
#app {
font-family: 'IRANSans', 'Iranian Sans','B Nazanin', 'Tahoma', ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, segoe ui, Roboto, helvetica neue, Arial, noto sans, sans-serif, apple color emoji, segoe ui emoji, segoe ui symbol, noto color emoji;
font-family: 'Vazirmatn', 'IRANSans', 'Iranian Sans','B Nazanin', 'Tahoma', ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, segoe ui, Roboto, helvetica neue, Arial, noto sans, sans-serif, apple color emoji, segoe ui emoji, segoe ui symbol, noto color emoji;
}
}

2
src/components/NotificationDialog.vue
View File

@@ -129,7 +129,6 @@ export default {
"Keep": "Keep",
"Kook": "Kook",
"line": "LINE Messenger",
"LineNotify": "LINE Notify",
"lunasea": "LunaSea",
"matrix": "Matrix",
"mattermost": "Mattermost",
@@ -173,6 +172,7 @@ export default {
"Cellsynt": "Cellsynt",
"SendGrid": "SendGrid",
"Brevo": "Brevo",
"Resend": "Resend",
"notifery": "Notifery",
"Webpush": "Webpush",
};

9
src/components/notifications/LineNotify.vue
View File

@@ -1,9 +0,0 @@
<template>
<div class="mb-3">
<label for="line-notify-access-token" class="form-label">{{ $t("Access Token") }}</label>
<input id="line-notify-access-token" v-model="$parent.notification.lineNotifyAccessToken" type="text" class="form-control" :required="true">
</div>
<i18n-t tag="div" keypath="wayToGetLineNotifyToken" class="form-text" style="margin-top: 8px;">
<a href="https://notify-bot.line.me/" target="_blank">https://notify-bot.line.me/</a>
</i18n-t>
</template>

48
src/components/notifications/Resend.vue Normal file
View File

@@ -0,0 +1,48 @@
<template>
<div class="mb-3">
<label for="resend-api-key" class="form-label">{{ $t("resendApiKey") }}</label>
<HiddenInput id="resend-api-key" v-model="$parent.notification.resendApiKey" :required="true" autocomplete="new-password"></HiddenInput>
<i18n-t tag="div" keypath="resendApiHelp" class="form-text">
<a href="https://resend.com/api-keys" target="_blank">https://resend.com/api-keys</a>
</i18n-t>
</div>
<div class="mb-3">
<label for="resend-from-email" class="form-label">{{ $t("resendFromEmail") }}</label>
<input id="resend-from-email" v-model="$parent.notification.resendFromEmail" type="text" class="form-control" required>
</div>
<div class="mb-3">
<label for="resend-from-name" class="form-label">{{ $t("resendFromName") }}</label>
<input id="resend-from-name" v-model="$parent.notification.resendFromName" type="text" class="form-control">
<div class="form-text">{{ $t("resendLeaveBlankForDefaultName") }}</div>
</div>
<div class="mb-3">
<label for="resend-to-email" class="form-label">{{ $t("resendToEmail") }}</label>
<input id="resend-to-email" v-model="$parent.notification.resendToEmail" type="text" class="form-control" required>
</div>
<div class="mb-3">
<label for="resend-subject" class="form-label">{{ $t("resendSubject") }}</label>
<input id="resend-subject" v-model="$parent.notification.resendSubject" type="text" class="form-control">
<small class="form-text text-muted">{{ $t("resendLeaveBlankForDefaultSubject") }}</small>
</div>
<i18n-t tag="p" keypath="More info on:" style="margin-top: 8px;">
<a href="https://resend.com/docs/dashboard/emails/introduction" target="_blank">https://resend.com/docs/dashboard/emails/introduction</a>
</i18n-t>
</template>
<script>
import HiddenInput from "../HiddenInput.vue";
export default {
components: {
HiddenInput,
},
mounted() {
if (typeof this.$parent.notification.resendSubject === "undefined") {
this.$parent.notification.resendSubject = "Notification from Your Uptime Kuma";
}
if (typeof this.$parent.notification.resendFromName === "undefined") {
this.$parent.notification.resendFromName = "Uptime Kuma";
}
},
};
</script>

4
src/components/notifications/index.js
View File

@@ -24,7 +24,6 @@ import HeiiOnCall from "./HeiiOnCall.vue";
import Keep from "./Keep.vue";
import Kook from "./Kook.vue";
import Line from "./Line.vue";
import LineNotify from "./LineNotify.vue";
import LunaSea from "./LunaSea.vue";
import Matrix from "./Matrix.vue";
import Mattermost from "./Mattermost.vue";
@@ -81,6 +80,7 @@ import YZJ from "./YZJ.vue";
import SMSPlanet from "./SMSPlanet.vue";
import SMSIR from "./SMSIR.vue";
import Webpush from "./Webpush.vue";
import Resend from "./Resend.vue";
/**
* Manage all notification form.
@@ -112,7 +112,6 @@ const NotificationFormList = {
"Keep": Keep,
"Kook": Kook,
"line": Line,
"LineNotify": LineNotify,
"lunasea": LunaSea,
"matrix": Matrix,
"mattermost": Mattermost,
@@ -167,6 +166,7 @@ const NotificationFormList = {
"WPush": WPush,
"SendGrid": SendGrid,
"Brevo": Brevo,
"Resend": Resend,
"YZJ": YZJ,
"SMSPlanet": SMSPlanet,
"Webpush": Webpush,

46
src/lang/en.json
View File

@@ -90,39 +90,9 @@
"upsideDownModeDescription": "Flip the status upside down. If the service is reachable, it is DOWN.",
"ignoreSecWebsocketAcceptHeaderDescription": "Allows the server to not reply with Sec-WebSocket-Accept header, if the websocket upgrade succeeds.",
"Ignore Sec-WebSocket-Accept header": "Ignore {0} header",
"wsSubprotocolDescription": "For more information on subprotocols, please consult the {documentation}",
"WebSocket Application Messaging Protocol": "WAMP (The WebSocket Application Messaging Protocol)",
"Session Initiation Protocol": "WebSocket Transport for SIP (Session Initiation Protocol)",
"Subprotocol": "Subprotocol",
"Network API for Notification Channel": "OMA RESTful Network API for Notification Channel",
"Web Process Control Protocol": "Web Process Control Protocol (WPCP)",
"Advanced Message Queuing Protocol": "Advanced Message Queuing Protocol (AMQP) 1.0+",
"jsflow": "jsFlow pubsub/queue Protocol",
"Reverse Web Process Control": "Reverse Web Process Control Protocol (RWPCP)",
"Extensible Messaging and Presence Protocol": "WebSocket Transport for the Extensible Messaging and Presence Protocol (XMPP)",
"Smart Home IP": "SHIP - Smart Home IP",
"Miele Cloud Connect Protocol": "Miele Cloud Connect Protocol",
"Push Channel Protocol": "Push Channel Protocol",
"Message Session Relay Protocol": "WebSocket Transport for MSRP (Message Session Relay Protocol)",
"Binary Floor Control Protocol": "WebSocket Transport for BFCP (Binary Floor Control Protocol)",
"Softvelum Low Delay Protocol": "Softvelum Low Delay Protocol",
"OPC UA Connection Protocol": "OPC UA Connection Protocol",
"OPC UA JSON Encoding": "OPC UA JSON Encoding",
"Swindon Web Server Protocol": "Swindon Web Server Protocol (JSON encoding)",
"Broadband Forum User Services Platform": "USP (Broadband Forum User Services Platform)",
"Constrained Application Protocol": "Constrained Application Protocol (CoAP)",
"Softvelum WebSocket signaling protocol": "Softvelum WebSocket Signaling Protocol",
"Cobra Real Time Messaging Protocol": "Cobra Real Time Messaging Protocol",
"Declarative Resource Protocol": "Declarative Resource Protocol",
"BACnet Secure Connect Hub Connection": "BACnet Secure Connect Hub Connection",
"BACnet Secure Connect Direct Connection": "BACnet Secure Connect Direct Connection",
"WebSocket Transport for JMAP": "WebSocket Transport for JMAP (JSON Meta Application Protocol)",
"ITU-T T.140 Real-Time Text": "ITU-T T.140 Real-Time Text",
"Done.best IoT Protocol": "Done.best IoT Protocol",
"Collection Update": "The Collection Update Websocket Subprotocol",
"Text IRC Protocol": "Text IRC Protocol",
"Binary IRC Protocol": "Binary IRC Protocol",
"Penguin Statistics Live Protocol v3": "Penguin Statistics Live Protocol v3 (Protobuf encoding)",
"wsSubprotocolDescription": "Enter a comma delimited list of subprotocols. For more information on subprotocols, please consult the {documentation}",
"wsCodeDescription": "For more information on status codes, please consult {rfc6455}",
"Subprotocol(s)": "Subprotocol(s)",
"maxRedirectDescription": "Maximum number of redirects to follow. Set to 0 to disable redirects.",
"Upside Down Mode": "Upside Down Mode",
"Max. Redirects": "Max. Redirects",
@@ -1183,6 +1153,13 @@
"brevoSeparateMultipleEmails": "Separate multiple email addresses with commas",
"brevoSubject": "Subject",
"brevoLeaveBlankForDefaultSubject": "leave blank for default subject",
"resendApiKey": "Resend API Key",
"resendApiHelp": "Create an api key here {0}",
"resendFromName": "From Name",
"resendFromEmail": "From Email",
"resendLeaveBlankForDefaultName": "leave blank for default name",
"resendToEmail": "To Email",
"resendSubject": "Subject",
"pingCountLabel": "Max Packets",
"pingCountDescription": "Number of packets to send before stopping",
"pingNumericLabel": "Numeric Output",
@@ -1246,5 +1223,6 @@
"labelDomainNameExpiryNotification": "Domain Name Expiry Notification",
"domainExpiryDescription": "Trigger notification when domain names expires in:",
"minimumIntervalWarning": "Intervals below 20 seconds may result in poor performance.",
"lowIntervalWarning": "Are you sure want to set the interval value below 20 seconds? Performance may be degraded, particularly if there are a large number of monitors."
"lowIntervalWarning": "Are you sure want to set the interval value below 20 seconds? Performance may be degraded, particularly if there are a large number of monitors.",
"imageResetConfirmation": "Image reset to default"
}

112
src/pages/EditMonitor.vue
View File

@@ -142,73 +142,8 @@
<!-- Websocket Subprotocol Docs: https://www.iana.org/assignments/websocket/websocket.xml#subprotocol-name -->
<div v-if="monitor.type === 'websocket-upgrade'" class="my-3">
<label for="ws_subprotocol" class="form-label">{{ $t("Subprotocol") }}</label>
<select id="ws_subprotocol" v-model="monitor.wsSubprotocol" class="form-select">
<option value="" selected>{{ $t("None") }}</option>
<option value="MBWS.huawei.com">MBWS</option>
<option value="MBLWS.huawei.com">MBLWS</option>
<option value="soap">soap</option>
<option value="wamp">{{ $t("WebSocket Application Messaging Protocol") }}</option>
<option value="v10.stomp">STOMP 1.0</option>
<option value="v11.stomp">STOMP 1.1</option>
<option value="v12.stomp">STOMP 1.2</option>
<option value="ocpp1.2">OCPP 1.2</option>
<option value="ocpp1.5">OCPP 1.5</option>
<option value="ocpp1.6">OCPP 1.6</option>
<option value="ocpp2.0">OCPP 2.0</option>
<option value="ocpp2.0.1">OCPP 2.0.1</option>
<option value="ocpp2.1">OCPP 2.1</option>
<option value="rfb">RFB</option>
<option value="sip">{{ $t("Session Initiation Protocol") }}</option>
<option value="notificationchannel-netapi-rest.openmobilealliance.org">{{ $t("Network API for Notification Channel") }}</option>
<option value="wpcp">{{ $t("Web Process Control Protocol") }}</option>
<option value="amqp">{{ $t("Advanced Message Queuing Protocol") }}</option>
<option value="mqtt">MQTT</option>
<option value="jsflow">{{ $t("jsflow") }}</option>
<option value="rwpcp">{{ $t("Reverse Web Process Control") }}</option>
<option value="xmpp">{{ $t("Extensible Messaging and Presence Protocol") }}</option>
<option value="ship">{{ $t("Smart Home IP") }}</option>
<option value="mielecloudconnect">{{ $t("Miele Cloud Connect Protocol") }}</option>
<option value="v10.pcp.sap.com">{{ $t("Push Channel Protocol") }}</option>
<option value="msrp">{{ $t("Message Session Relay Protocol") }}</option>
<option value="v1.saltyrtc.org">SaltyRTC 1.0</option>
<option value="TLCP-2.0.0.lightstreamer.com">TLCP 2.0.0</option>
<option value="bfcp">{{ $t("Binary Floor Control Protocol") }}</option>
<option value="sldp.softvelum.com">{{ $t("Softvelum Low Delay Protocol") }}</option>
<option value="opcua+uacp">{{ $t("OPC UA Connection Protocol") }}</option>
<option value="opcua+uajson">{{ $t("OPC UA JSON Encoding") }}</option>
<option value="v1.swindon-lattice+json">{{ $t("Swindon Web Server Protocol") }}</option>
<option value="v1.usp">{{ $t("Broadband Forum User Services Platform") }}</option>
<option value="mles-websocket">mles-websocket</option>
<option value="coap">{{ $t("Constrained Application Protocol") }}</option>
<option value="TLCP-2.1.0.lightstreamer.com">TLCP 2.1.0</option>
<option value="sqlnet.oracle.com">sqlnet</option>
<option value="oneM2M.R2.0.json">oneM2M R2.0 JSON</option>
<option value="oneM2M.R2.0.xml">oneM2M R2.0 XML</option>
<option value="oneM2M.R2.0.cbor">oneM2M R2.0 CBOR</option>
<option value="transit">Transit</option>
<option value="2016.serverpush.dash.mpeg.org">MPEG-DASH-ServerPush-23009-6-2017</option>
<option value="2018.mmt.mpeg.org">MPEG-MMT-23008-1-2018</option>
<option value="clue">clue</option>
<option value="webrtc.softvelum.com">{{ $t("Softvelum WebSocket signaling protocol") }}</option>
<option value="cobra.v2.json">{{ $t("Cobra Real Time Messaging Protocol") }}</option>
<option value="drp">{{ $t("Declarative Resource Protocol") }}</option>
<option value="hub.bsc.bacnet.org">{{ $t("BACnet Secure Connect Hub Connection") }}</option>
<option value="dc.bsc.bacnet.org">{{ $t("BACnet Secure Connect Direct Connection") }}</option>
<option value="jmap">{{ $t("WebSocket Transport for JMAP") }}</option>
<option value="t140">{{ $t("ITU-T T.140 Real-Time Text") }}</option>
<option value="done">{{ $t("Done.best IoT Protocol") }}</option>
<option value="TLCP-2.2.0.lightstreamer.com">TLCP 2.2.0</option>
<option value="collection-update">{{ $t("Collection Update") }}</option>
<option value="TLCP-2.3.0.lightstreamer.com">TLCP 2.3.0</option>
<option value="text.ircv3.net">{{ $t("Text IRC Protocol") }}</option>
<option value="binary.ircv3.net">{{ $t("Binary IRC Protocol") }}</option>
<option value="v3.penguin-stats.live+proto">{{ $t("Penguin Statistics Live Protocol v3") }}</option>
<option value="TLCP-2.4.0.lightstreamer.com">TLCP 2.4.0</option>
<option value="TLCP-2.5.0.lightstreamer.com">TLCP 2.5.0</option>
<option value="Redfish">Redfish DSP0266</option>
<option value="bidib">webBiDiB</option>
</select>
<label for="ws_subprotocol" class="form-label">{{ $t("Subprotocol(s)") }}</label>
<input id="ws_subprotocol" v-model="monitor.wsSubprotocol" type="text" class="form-control" placeholder="mielecloudconnect,soap">
<i18n-t tag="div" class="form-text" keypath="wsSubprotocolDescription">
<template #documentation>
<a href="https://www.iana.org/assignments/websocket/websocket.xml#subprotocol-name" target="_blank" rel="noopener noreferrer">{{ $t('documentationOf', ['IANA']) }}</a>
@@ -767,8 +702,8 @@
</div>
</div>
<!-- Timeout: HTTP / JSON query / Keyword / Ping / RabbitMQ / SNMP only -->
<div v-if="monitor.type === 'http' || monitor.type === 'json-query' || monitor.type === 'keyword' || monitor.type === 'ping' || monitor.type === 'rabbitmq' || monitor.type === 'snmp'" class="my-3">
<!-- Timeout: HTTP / JSON query / Keyword / Ping / RabbitMQ / SNMP / Websocket Upgrade only -->
<div v-if="monitor.type === 'http' || monitor.type === 'json-query' || monitor.type === 'keyword' || monitor.type === 'ping' || monitor.type === 'rabbitmq' || monitor.type === 'snmp' || monitor.type === 'websocket-upgrade'" class="my-3">
<label for="timeout" class="form-label">
{{ monitor.type === 'ping' ? $t("pingGlobalTimeoutLabel") : $t("Request Timeout") }}
<span v-if="monitor.type !== 'ping'">({{ $t("timeoutAfter", [monitor.timeout || clampTimeout(monitor.interval)]) }})</span>
@@ -889,6 +824,36 @@
</div>
</div>
<!-- Websocket Upgrade only -->
<template v-if="monitor.type === 'websocket-upgrade' ">
<div class="my-3">
<label for="acceptedStatusCodes" class="form-label">{{ $t("Accepted Status Codes") }}</label>
<VueMultiselect
id="acceptedStatusCodes"
v-model="monitor.accepted_statuscodes"
:options="acceptedWebsocketCodeOptions"
:multiple="true"
:close-on-select="false"
:clear-on-select="false"
:preserve-search="true"
:placeholder="$t('Pick Accepted Status Codes...')"
:preselect-first="false"
:max-height="600"
:taggable="true"
></VueMultiselect>
<div class="form-text">
{{ $t("acceptedStatusCodesDescription") }}
</div>
<i18n-t tag="div" class="form-text" keypath="wsCodeDescription">
<template #rfc6455>
<a href="https://datatracker.ietf.org/doc/html/rfc6455#section-7.4" target="_blank" rel="noopener noreferrer">RFC 6455</a>
</template>
</i18n-t>
</div>
</template>
<!-- HTTP / Keyword only -->
<template v-if="monitor.type === 'http' || monitor.type === 'keyword' || monitor.type === 'json-query' || monitor.type === 'grpc-keyword' ">
<div class="my-3">
@@ -1398,6 +1363,7 @@ export default {
},
hasDomain: false,
acceptedStatusCodeOptions: [],
acceptedWebsocketCodeOptions: [],
dnsresolvetypeOptions: [],
kafkaSaslMechanismOptions: [],
ipOrHostnameRegexPattern: hostNameRegexPattern(),
@@ -1770,6 +1736,7 @@ message HealthCheckResponse {
"monitor.type"(newType, oldType) {
if (oldType && this.monitor.type === "websocket-upgrade") {
this.monitor.url = "wss://";
this.monitor.accepted_statuscodes = [ "1000" ];
}
if (this.monitor.type === "push") {
if (! this.monitor.pushToken) {
@@ -1877,6 +1844,8 @@ message HealthCheckResponse {
"500-599",
];
let acceptedWebsocketCodeOptions = [];
let dnsresolvetypeOptions = [
"A",
"AAAA",
@@ -1902,6 +1871,11 @@ message HealthCheckResponse {
acceptedStatusCodeOptions.push(i.toString());
}
for (let i = 1000; i <= 4999; i++) {
acceptedWebsocketCodeOptions.push(i.toString());
}
this.acceptedWebsocketCodeOptions = acceptedWebsocketCodeOptions;
this.acceptedStatusCodeOptions = acceptedStatusCodeOptions;
this.dnsresolvetypeOptions = dnsresolvetypeOptions;
this.kafkaSaslMechanismOptions = kafkaSaslMechanismOptions;

69
src/pages/StatusPage.vue
View File

@@ -138,6 +138,9 @@
<h1 class="mb-4 title-flex">
<!-- Logo -->
<span class="logo-wrapper" @click="showImageCropUploadMethod">
<button v-if="editMode" type="button" class="p-0 bg-transparent border-0 small-reset-btn reset-top-left" @click.stop="resetToDefaultImage">
<font-awesome-icon icon="times" class="text-danger" />
</button>
<img :src="logoURL" alt class="logo me-2" :class="logoClass" />
<font-awesome-icon v-if="enableEditMode" class="icon-upload" icon="upload" />
</span>
@@ -962,6 +965,20 @@ export default {
}
},
/**
* Reset logo image to default (public/icon.svg)
* @returns {void}
*/
resetToDefaultImage() {
if (! this.editMode) {
return;
}
this.imgDataUrl = "/icon.svg";
this.config.icon = this.imgDataUrl;
toast.success(this.$t("imageResetConfirmation"));
},
/**
* Create an incident for this status page
* @returns {void}
@@ -1181,6 +1198,58 @@ footer {
cursor: pointer;
box-shadow: 0 15px 70px rgba(0, 0, 0, 0.9);
}
/* Reset button placed at top-left of the logo */
.reset-top-left {
position: absolute;
top: 0;
left: -15px;
z-index: 2;
width: 20px;
height: 20px;
display: inline-flex;
align-items: center;
justify-content: center;
border-radius: 50%;
background: white;
border: none;
box-shadow: 0 1px 4px rgba(0, 0, 0, 0.2);
cursor: pointer;
padding: 0;
transition: transform $easing-in 0.18s, box-shadow $easing-in 0.18s, background-color $easing-in 0.18s;
transform-origin: center;
&:hover {
background-color: rgba(0, 0, 0, 0.06);
transform: scale(1.18);
box-shadow: 0 6px 18px rgba(0, 0, 0, 0.18);
}
&:hover ~ .icon-upload {
transform: none !important;
}
}
.small-reset-btn {
transition: transform $easing-in 0.18s, box-shadow $easing-in 0.18s, background-color $easing-in 0.18s;
font-size: 18px;
width: 18px;
height: 18px;
padding: 0;
display: inline-flex;
align-items: center;
justify-content: center;
border-radius: 50%;
background: transparent;
border: none;
cursor: pointer;
&:hover {
background-color: rgba(0, 0, 0, 0.04);
transform: scale(1.18);
box-shadow: 0 6px 18px rgba(0, 0, 0, 0.12);
}
}
}
.logo {

18
test/backend-test/README.md
View File

@@ -4,14 +4,26 @@ Documentation: https://nodejs.org/api/test.html
Create a test file in this directory with the name `*.js`.
> [!TIP]
> Writing great tests is hard.
>
> You can make our live much simpler by following this guidance:
> - Use `describe()` to group related tests
> - Use `test()` for individual test cases
> - One test per scenario
> - Use descriptive test names: `function() [behavior] [condition]`
> - Don't prefix with "Test" or "Should"
## Template
```js
const test = require("node:test");
const { describe, test } = require("node:test");
const assert = require("node:assert");
test("Test name", async (t) => {
assert.strictEqual(1, 1);
describe("Feature Name", () => {
test("function() returns expected value when condition is met", () => {
assert.strictEqual(1, 1);
});
});
```

76
test/backend-test/monitor-conditions/test-evaluator.js
View File

@@ -1,46 +1,48 @@
const test = require("node:test");
const { describe, test } = require("node:test");
const assert = require("node:assert");
const { ConditionExpressionGroup, ConditionExpression, LOGICAL } = require("../../../server/monitor-conditions/expression.js");
const { evaluateExpressionGroup, evaluateExpression } = require("../../../server/monitor-conditions/evaluator.js");
test("Test evaluateExpression", async (t) => {
const expr = new ConditionExpression("record", "contains", "mx1.example.com");
assert.strictEqual(true, evaluateExpression(expr, { record: "mx1.example.com" }));
assert.strictEqual(false, evaluateExpression(expr, { record: "mx2.example.com" }));
});
describe("Expression Evaluator", () => {
test("evaluateExpression() returns true when condition matches and false otherwise", () => {
const expr = new ConditionExpression("record", "contains", "mx1.example.com");
assert.strictEqual(true, evaluateExpression(expr, { record: "mx1.example.com" }));
assert.strictEqual(false, evaluateExpression(expr, { record: "mx2.example.com" }));
});
test("Test evaluateExpressionGroup with logical AND", async (t) => {
const group = new ConditionExpressionGroup([
new ConditionExpression("record", "contains", "mx1."),
new ConditionExpression("record", "contains", "example.com", LOGICAL.AND),
]);
assert.strictEqual(true, evaluateExpressionGroup(group, { record: "mx1.example.com" }));
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "mx1." }));
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "example.com" }));
});
test("evaluateExpressionGroup() with AND logic requires all conditions to be true", () => {
const group = new ConditionExpressionGroup([
new ConditionExpression("record", "contains", "mx1."),
new ConditionExpression("record", "contains", "example.com", LOGICAL.AND),
]);
assert.strictEqual(true, evaluateExpressionGroup(group, { record: "mx1.example.com" }));
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "mx1." }));
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "example.com" }));
});
test("Test evaluateExpressionGroup with logical OR", async (t) => {
const group = new ConditionExpressionGroup([
new ConditionExpression("record", "contains", "example.com"),
new ConditionExpression("record", "contains", "example.org", LOGICAL.OR),
]);
assert.strictEqual(true, evaluateExpressionGroup(group, { record: "example.com" }));
assert.strictEqual(true, evaluateExpressionGroup(group, { record: "example.org" }));
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "example.net" }));
});
test("Test evaluateExpressionGroup with nested group", async (t) => {
const group = new ConditionExpressionGroup([
new ConditionExpression("record", "contains", "mx1."),
new ConditionExpressionGroup([
test("evaluateExpressionGroup() with OR logic requires at least one condition to be true", () => {
const group = new ConditionExpressionGroup([
new ConditionExpression("record", "contains", "example.com"),
new ConditionExpression("record", "contains", "example.org", LOGICAL.OR),
]),
]);
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "mx1." }));
assert.strictEqual(true, evaluateExpressionGroup(group, { record: "mx1.example.com" }));
assert.strictEqual(true, evaluateExpressionGroup(group, { record: "mx1.example.org" }));
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "example.com" }));
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "example.org" }));
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "mx1.example.net" }));
]);
assert.strictEqual(true, evaluateExpressionGroup(group, { record: "example.com" }));
assert.strictEqual(true, evaluateExpressionGroup(group, { record: "example.org" }));
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "example.net" }));
});
test("evaluateExpressionGroup() evaluates nested groups correctly", () => {
const group = new ConditionExpressionGroup([
new ConditionExpression("record", "contains", "mx1."),
new ConditionExpressionGroup([
new ConditionExpression("record", "contains", "example.com"),
new ConditionExpression("record", "contains", "example.org", LOGICAL.OR),
]),
]);
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "mx1." }));
assert.strictEqual(true, evaluateExpressionGroup(group, { record: "mx1.example.com" }));
assert.strictEqual(true, evaluateExpressionGroup(group, { record: "mx1.example.org" }));
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "example.com" }));
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "example.org" }));
assert.strictEqual(false, evaluateExpressionGroup(group, { record: "mx1.example.net" }));
});
});

180
test/backend-test/monitor-conditions/test-operators.js
View File

@@ -1,108 +1,110 @@
const test = require("node:test");
const { describe, test } = require("node:test");
const assert = require("node:assert");
const { operatorMap, OP_CONTAINS, OP_NOT_CONTAINS, OP_LT, OP_GT, OP_LTE, OP_GTE, OP_STR_EQUALS, OP_STR_NOT_EQUALS, OP_NUM_EQUALS, OP_NUM_NOT_EQUALS, OP_STARTS_WITH, OP_ENDS_WITH, OP_NOT_STARTS_WITH, OP_NOT_ENDS_WITH } = require("../../../server/monitor-conditions/operators.js");
test("Test StringEqualsOperator", async (t) => {
const op = operatorMap.get(OP_STR_EQUALS);
assert.strictEqual(true, op.test("mx1.example.com", "mx1.example.com"));
assert.strictEqual(false, op.test("mx1.example.com", "mx1.example.org"));
assert.strictEqual(false, op.test("1", 1)); // strict equality
});
describe("Expression Operators", () => {
test("StringEqualsOperator returns true for identical strings and false otherwise", () => {
const op = operatorMap.get(OP_STR_EQUALS);
assert.strictEqual(true, op.test("mx1.example.com", "mx1.example.com"));
assert.strictEqual(false, op.test("mx1.example.com", "mx1.example.org"));
assert.strictEqual(false, op.test("1", 1)); // strict equality
});
test("Test StringNotEqualsOperator", async (t) => {
const op = operatorMap.get(OP_STR_NOT_EQUALS);
assert.strictEqual(true, op.test("mx1.example.com", "mx1.example.org"));
assert.strictEqual(false, op.test("mx1.example.com", "mx1.example.com"));
assert.strictEqual(true, op.test(1, "1")); // variable is not typecasted (strict equality)
});
test("StringNotEqualsOperator returns true for different strings and false for identical strings", () => {
const op = operatorMap.get(OP_STR_NOT_EQUALS);
assert.strictEqual(true, op.test("mx1.example.com", "mx1.example.org"));
assert.strictEqual(false, op.test("mx1.example.com", "mx1.example.com"));
assert.strictEqual(true, op.test(1, "1")); // variable is not typecasted (strict equality)
});
test("Test ContainsOperator with scalar", async (t) => {
const op = operatorMap.get(OP_CONTAINS);
assert.strictEqual(true, op.test("mx1.example.org", "example.org"));
assert.strictEqual(false, op.test("mx1.example.org", "example.com"));
});
test("ContainsOperator returns true when scalar contains substring", () => {
const op = operatorMap.get(OP_CONTAINS);
assert.strictEqual(true, op.test("mx1.example.org", "example.org"));
assert.strictEqual(false, op.test("mx1.example.org", "example.com"));
});
test("Test ContainsOperator with array", async (t) => {
const op = operatorMap.get(OP_CONTAINS);
assert.strictEqual(true, op.test([ "example.org" ], "example.org"));
assert.strictEqual(false, op.test([ "example.org" ], "example.com"));
});
test("ContainsOperator returns true when array contains element", () => {
const op = operatorMap.get(OP_CONTAINS);
assert.strictEqual(true, op.test([ "example.org" ], "example.org"));
assert.strictEqual(false, op.test([ "example.org" ], "example.com"));
});
test("Test NotContainsOperator with scalar", async (t) => {
const op = operatorMap.get(OP_NOT_CONTAINS);
assert.strictEqual(true, op.test("example.org", ".com"));
assert.strictEqual(false, op.test("example.org", ".org"));
});
test("NotContainsOperator returns true when scalar does not contain substring", () => {
const op = operatorMap.get(OP_NOT_CONTAINS);
assert.strictEqual(true, op.test("example.org", ".com"));
assert.strictEqual(false, op.test("example.org", ".org"));
});
test("Test NotContainsOperator with array", async (t) => {
const op = operatorMap.get(OP_NOT_CONTAINS);
assert.strictEqual(true, op.test([ "example.org" ], "example.com"));
assert.strictEqual(false, op.test([ "example.org" ], "example.org"));
});
test("NotContainsOperator returns true when array does not contain element", () => {
const op = operatorMap.get(OP_NOT_CONTAINS);
assert.strictEqual(true, op.test([ "example.org" ], "example.com"));
assert.strictEqual(false, op.test([ "example.org" ], "example.org"));
});
test("Test StartsWithOperator", async (t) => {
const op = operatorMap.get(OP_STARTS_WITH);
assert.strictEqual(true, op.test("mx1.example.com", "mx1"));
assert.strictEqual(false, op.test("mx1.example.com", "mx2"));
});
test("StartsWithOperator returns true when string starts with prefix", () => {
const op = operatorMap.get(OP_STARTS_WITH);
assert.strictEqual(true, op.test("mx1.example.com", "mx1"));
assert.strictEqual(false, op.test("mx1.example.com", "mx2"));
});
test("Test NotStartsWithOperator", async (t) => {
const op = operatorMap.get(OP_NOT_STARTS_WITH);
assert.strictEqual(true, op.test("mx1.example.com", "mx2"));
assert.strictEqual(false, op.test("mx1.example.com", "mx1"));
});
test("NotStartsWithOperator returns true when string does not start with prefix", () => {
const op = operatorMap.get(OP_NOT_STARTS_WITH);
assert.strictEqual(true, op.test("mx1.example.com", "mx2"));
assert.strictEqual(false, op.test("mx1.example.com", "mx1"));
});
test("Test EndsWithOperator", async (t) => {
const op = operatorMap.get(OP_ENDS_WITH);
assert.strictEqual(true, op.test("mx1.example.com", "example.com"));
assert.strictEqual(false, op.test("mx1.example.com", "example.net"));
});
test("EndsWithOperator returns true when string ends with suffix", () => {
const op = operatorMap.get(OP_ENDS_WITH);
assert.strictEqual(true, op.test("mx1.example.com", "example.com"));
assert.strictEqual(false, op.test("mx1.example.com", "example.net"));
});
test("Test NotEndsWithOperator", async (t) => {
const op = operatorMap.get(OP_NOT_ENDS_WITH);
assert.strictEqual(true, op.test("mx1.example.com", "example.net"));
assert.strictEqual(false, op.test("mx1.example.com", "example.com"));
});
test("NotEndsWithOperator returns true when string does not end with suffix", () => {
const op = operatorMap.get(OP_NOT_ENDS_WITH);
assert.strictEqual(true, op.test("mx1.example.com", "example.net"));
assert.strictEqual(false, op.test("mx1.example.com", "example.com"));
});
test("Test NumberEqualsOperator", async (t) => {
const op = operatorMap.get(OP_NUM_EQUALS);
assert.strictEqual(true, op.test(1, 1));
assert.strictEqual(true, op.test(1, "1"));
assert.strictEqual(false, op.test(1, "2"));
});
test("NumberEqualsOperator returns true for equal numbers with type coercion", () => {
const op = operatorMap.get(OP_NUM_EQUALS);
assert.strictEqual(true, op.test(1, 1));
assert.strictEqual(true, op.test(1, "1"));
assert.strictEqual(false, op.test(1, "2"));
});
test("Test NumberNotEqualsOperator", async (t) => {
const op = operatorMap.get(OP_NUM_NOT_EQUALS);
assert.strictEqual(true, op.test(1, "2"));
assert.strictEqual(false, op.test(1, "1"));
});
test("NumberNotEqualsOperator returns true for different numbers", () => {
const op = operatorMap.get(OP_NUM_NOT_EQUALS);
assert.strictEqual(true, op.test(1, "2"));
assert.strictEqual(false, op.test(1, "1"));
});
test("Test LessThanOperator", async (t) => {
const op = operatorMap.get(OP_LT);
assert.strictEqual(true, op.test(1, 2));
assert.strictEqual(true, op.test(1, "2"));
assert.strictEqual(false, op.test(1, 1));
});
test("LessThanOperator returns true when first number is less than second", () => {
const op = operatorMap.get(OP_LT);
assert.strictEqual(true, op.test(1, 2));
assert.strictEqual(true, op.test(1, "2"));
assert.strictEqual(false, op.test(1, 1));
});
test("Test GreaterThanOperator", async (t) => {
const op = operatorMap.get(OP_GT);
assert.strictEqual(true, op.test(2, 1));
assert.strictEqual(true, op.test(2, "1"));
assert.strictEqual(false, op.test(1, 1));
});
test("GreaterThanOperator returns true when first number is greater than second", () => {
const op = operatorMap.get(OP_GT);
assert.strictEqual(true, op.test(2, 1));
assert.strictEqual(true, op.test(2, "1"));
assert.strictEqual(false, op.test(1, 1));
});
test("Test LessThanOrEqualToOperator", async (t) => {
const op = operatorMap.get(OP_LTE);
assert.strictEqual(true, op.test(1, 1));
assert.strictEqual(true, op.test(1, 2));
assert.strictEqual(true, op.test(1, "2"));
assert.strictEqual(false, op.test(1, 0));
});
test("LessThanOrEqualToOperator returns true when first number is less than or equal to second", () => {
const op = operatorMap.get(OP_LTE);
assert.strictEqual(true, op.test(1, 1));
assert.strictEqual(true, op.test(1, 2));
assert.strictEqual(true, op.test(1, "2"));
assert.strictEqual(false, op.test(1, 0));
});
test("Test GreaterThanOrEqualToOperator", async (t) => {
const op = operatorMap.get(OP_GTE);
assert.strictEqual(true, op.test(1, 1));
assert.strictEqual(true, op.test(2, 1));
assert.strictEqual(true, op.test(2, "2"));
assert.strictEqual(false, op.test(2, 3));
test("GreaterThanOrEqualToOperator returns true when first number is greater than or equal to second", () => {
const op = operatorMap.get(OP_GTE);
assert.strictEqual(true, op.test(1, 1));
assert.strictEqual(true, op.test(2, 1));
assert.strictEqual(true, op.test(2, "2"));
assert.strictEqual(false, op.test(2, 3));
});
});

16
test/backend-test/test-grpc.js → test/backend-test/monitors/test-grpc.js
View File

@@ -2,8 +2,8 @@ const { describe, test } = require("node:test");
const assert = require("node:assert");
const grpc = require("@grpc/grpc-js");
const protoLoader = require("@grpc/proto-loader");
const { GrpcKeywordMonitorType } = require("../../server/monitor-types/grpc");
const { UP, PENDING } = require("../../src/util");
const { GrpcKeywordMonitorType } = require("../../../server/monitor-types/grpc");
const { UP, PENDING } = require("../../../src/util");
const fs = require("fs");
const path = require("path");
const os = require("os");
@@ -82,7 +82,7 @@ async function createTestGrpcServer(port, methodHandlers) {
describe("GrpcKeywordMonitorType", {
skip: !!process.env.CI && (process.platform !== "linux" || process.arch !== "x64"),
}, () => {
test("gRPC keyword found in response", async () => {
test("check() sets status to UP when keyword is found in response", async () => {
const port = 50051;
const server = await createTestGrpcServer(port, {
Echo: (call, callback) => {
@@ -118,7 +118,7 @@ describe("GrpcKeywordMonitorType", {
}
});
test("gRPC keyword not found in response", async () => {
test("check() rejects when keyword is not found in response", async () => {
const port = 50052;
const server = await createTestGrpcServer(port, {
Echo: (call, callback) => {
@@ -158,7 +158,7 @@ describe("GrpcKeywordMonitorType", {
}
});
test("gRPC inverted keyword - keyword present (should fail)", async () => {
test("check() rejects when inverted keyword is present in response", async () => {
const port = 50053;
const server = await createTestGrpcServer(port, {
Echo: (call, callback) => {
@@ -198,7 +198,7 @@ describe("GrpcKeywordMonitorType", {
}
});
test("gRPC inverted keyword - keyword not present (should pass)", async () => {
test("check() sets status to UP when inverted keyword is not present in response", async () => {
const port = 50054;
const server = await createTestGrpcServer(port, {
Echo: (call, callback) => {
@@ -234,7 +234,7 @@ describe("GrpcKeywordMonitorType", {
}
});
test("gRPC connection failure", async () => {
test("check() rejects when gRPC server is unreachable", async () => {
const grpcMonitor = new GrpcKeywordMonitorType();
const monitor = {
grpcUrl: "localhost:50099",
@@ -262,7 +262,7 @@ describe("GrpcKeywordMonitorType", {
);
});
test("gRPC response truncation for long messages", async () => {
test("check() truncates long response messages in error output", async () => {
const port = 50055;
const longMessage = "A".repeat(100) + " with SUCCESS keyword";

34
test/backend-test/test-mqtt.js → test/backend-test/monitors/test-mqtt.js
View File

@@ -2,8 +2,8 @@ const { describe, test } = require("node:test");
const assert = require("node:assert");
const { HiveMQContainer } = require("@testcontainers/hivemq");
const mqtt = require("mqtt");
const { MqttMonitorType } = require("../../server/monitor-types/mqtt");
const { UP, PENDING } = require("../../src/util");
const { MqttMonitorType } = require("../../../server/monitor-types/mqtt");
const { UP, PENDING } = require("../../../src/util");
/**
* Runs an MQTT test with the
@@ -58,91 +58,91 @@ describe("MqttMonitorType", {
concurrency: 4,
skip: !!process.env.CI && (process.platform !== "linux" || process.arch !== "x64")
}, () => {
test("valid keywords (type=default)", async () => {
test("check() sets status to UP when keyword is found in message (type=default)", async () => {
const heartbeat = await testMqtt("KEYWORD", null, "-> KEYWORD <-");
assert.strictEqual(heartbeat.status, UP);
assert.strictEqual(heartbeat.msg, "Topic: test; Message: -> KEYWORD <-");
});
test("valid nested topic", async () => {
test("check() sets status to UP when keyword is found in nested topic", async () => {
const heartbeat = await testMqtt("KEYWORD", null, "-> KEYWORD <-", "a/b/c", "a/b/c");
assert.strictEqual(heartbeat.status, UP);
assert.strictEqual(heartbeat.msg, "Topic: a/b/c; Message: -> KEYWORD <-");
});
test("valid nested topic (with special chars)", async () => {
test("check() sets status to UP when keyword is found in nested topic with special characters", async () => {
const heartbeat = await testMqtt("KEYWORD", null, "-> KEYWORD <-", "a/'/$/./*/%", "a/'/$/./*/%");
assert.strictEqual(heartbeat.status, UP);
assert.strictEqual(heartbeat.msg, "Topic: a/'/$/./*/%; Message: -> KEYWORD <-");
});
test("valid wildcard topic (with #)", async () => {
test("check() sets status to UP when keyword is found using # wildcard", async () => {
const heartbeat = await testMqtt("KEYWORD", null, "-> KEYWORD <-", "a/#", "a/b/c");
assert.strictEqual(heartbeat.status, UP);
assert.strictEqual(heartbeat.msg, "Topic: a/b/c; Message: -> KEYWORD <-");
});
test("valid wildcard topic (with +)", async () => {
test("check() sets status to UP when keyword is found using + wildcard", async () => {
const heartbeat = await testMqtt("KEYWORD", null, "-> KEYWORD <-", "a/+/c", "a/b/c");
assert.strictEqual(heartbeat.status, UP);
assert.strictEqual(heartbeat.msg, "Topic: a/b/c; Message: -> KEYWORD <-");
});
test("valid wildcard topic (with + and #)", async () => {
test("check() sets status to UP when keyword is found using + and # wildcards", async () => {
const heartbeat = await testMqtt("KEYWORD", null, "-> KEYWORD <-", "a/+/c/#", "a/b/c/d/e");
assert.strictEqual(heartbeat.status, UP);
assert.strictEqual(heartbeat.msg, "Topic: a/b/c/d/e; Message: -> KEYWORD <-");
});
test("invalid topic", async () => {
test("check() rejects with timeout when topic does not match", async () => {
await assert.rejects(
testMqtt("keyword will not be checked anyway", null, "message", "x/y/z", "a/b/c"),
new Error("Timeout, Message not received"),
);
});
test("invalid wildcard topic (with #)", async () => {
test("check() rejects with timeout when # wildcard is not last character", async () => {
await assert.rejects(
testMqtt("", null, "# should be last character", "#/c", "a/b/c"),
new Error("Timeout, Message not received"),
);
});
test("invalid wildcard topic (with +)", async () => {
test("check() rejects with timeout when + wildcard topic does not match", async () => {
await assert.rejects(
testMqtt("", null, "message", "x/+/z", "a/b/c"),
new Error("Timeout, Message not received"),
);
});
test("valid keywords (type=keyword)", async () => {
test("check() sets status to UP when keyword is found in message (type=keyword)", async () => {
const heartbeat = await testMqtt("KEYWORD", "keyword", "-> KEYWORD <-");
assert.strictEqual(heartbeat.status, UP);
assert.strictEqual(heartbeat.msg, "Topic: test; Message: -> KEYWORD <-");
});
test("invalid keywords (type=default)", async () => {
test("check() rejects when keyword is not found in message (type=default)", async () => {
await assert.rejects(
testMqtt("NOT_PRESENT", null, "-> KEYWORD <-"),
new Error("Message Mismatch - Topic: test; Message: -> KEYWORD <-"),
);
});
test("invalid keyword (type=keyword)", async () => {
test("check() rejects when keyword is not found in message (type=keyword)", async () => {
await assert.rejects(
testMqtt("NOT_PRESENT", "keyword", "-> KEYWORD <-"),
new Error("Message Mismatch - Topic: test; Message: -> KEYWORD <-"),
);
});
test("valid json-query", async () => {
test("check() sets status to UP when json-query finds expected value", async () => {
// works because the monitors' jsonPath is hard-coded to "firstProp"
const heartbeat = await testMqtt("present", "json-query", "{\"firstProp\":\"present\"}");
assert.strictEqual(heartbeat.status, UP);
assert.strictEqual(heartbeat.msg, "Message received, expected value is found");
});
test("invalid (because query fails) json-query", async () => {
test("check() rejects when json-query path returns undefined", async () => {
// works because the monitors' jsonPath is hard-coded to "firstProp"
await assert.rejects(
testMqtt("[not_relevant]", "json-query", "{}"),
@@ -150,7 +150,7 @@ describe("MqttMonitorType", {
);
});
test("invalid (because successMessage fails) json-query", async () => {
test("check() rejects when json-query value does not match expected value", async () => {
// works because the monitors' jsonPath is hard-coded to "firstProp"
await assert.rejects(
testMqtt("[wrong_success_messsage]", "json-query", "{\"firstProp\":\"present\"}"),

302
test/backend-test/monitors/test-mssql.js Normal file
View File

@@ -0,0 +1,302 @@
const { describe, test } = require("node:test");
const assert = require("node:assert");
const { MSSQLServerContainer } = require("@testcontainers/mssqlserver");
const { MssqlMonitorType } = require("../../../server/monitor-types/mssql");
const { UP, PENDING } = require("../../../src/util");
/**
* Helper function to create and start a MSSQL container
* @returns {Promise<MSSQLServerContainer>} The started MSSQL container
*/
async function createAndStartMSSQLContainer() {
return await new MSSQLServerContainer(
"mcr.microsoft.com/mssql/server:2022-latest"
)
.acceptLicense()
// The default timeout of 30 seconds might not be enough for the container to start
.withStartupTimeout(60000)
.start();
}
describe(
"MSSQL Single Node",
{
skip:
!!process.env.CI &&
(process.platform !== "linux" || process.arch !== "x64"),
},
() => {
test("check() sets status to UP when MSSQL server is reachable", async () => {
let mssqlContainer;
try {
mssqlContainer = await createAndStartMSSQLContainer();
const mssqlMonitor = new MssqlMonitorType();
const monitor = {
databaseConnectionString:
mssqlContainer.getConnectionUri(false),
conditions: "[]",
};
const heartbeat = {
msg: "",
status: PENDING,
};
await mssqlMonitor.check(monitor, heartbeat, {});
assert.strictEqual(
heartbeat.status,
UP,
`Expected status ${UP} but got ${heartbeat.status}`
);
} catch (error) {
console.error("Test failed with error:", error.message);
console.error("Error stack:", error.stack);
if (mssqlContainer) {
console.error("Container ID:", mssqlContainer.getId());
console.error(
"Container logs:",
await mssqlContainer.logs()
);
}
throw error;
} finally {
if (mssqlContainer) {
console.log("Stopping MSSQL container...");
await mssqlContainer.stop();
}
}
});
test("check() sets status to UP when custom query returns single value", async () => {
const mssqlContainer = await createAndStartMSSQLContainer();
const mssqlMonitor = new MssqlMonitorType();
const monitor = {
databaseConnectionString:
mssqlContainer.getConnectionUri(false),
databaseQuery: "SELECT 42",
conditions: "[]",
};
const heartbeat = {
msg: "",
status: PENDING,
};
try {
await mssqlMonitor.check(monitor, heartbeat, {});
assert.strictEqual(
heartbeat.status,
UP,
`Expected status ${UP} but got ${heartbeat.status}`
);
} finally {
await mssqlContainer.stop();
}
});
test("check() sets status to UP when custom query result meets condition", async () => {
const mssqlContainer = await createAndStartMSSQLContainer();
const mssqlMonitor = new MssqlMonitorType();
const monitor = {
databaseConnectionString:
mssqlContainer.getConnectionUri(false),
databaseQuery: "SELECT 42 as value",
conditions: JSON.stringify([
{
type: "expression",
andOr: "and",
variable: "result",
operator: "equals",
value: "42",
},
]),
};
const heartbeat = {
msg: "",
status: PENDING,
};
try {
await mssqlMonitor.check(monitor, heartbeat, {});
assert.strictEqual(
heartbeat.status,
UP,
`Expected status ${UP} but got ${heartbeat.status}`
);
} finally {
await mssqlContainer.stop();
}
});
test("check() rejects when custom query result does not meet condition", async () => {
const mssqlContainer = await createAndStartMSSQLContainer();
const mssqlMonitor = new MssqlMonitorType();
const monitor = {
databaseConnectionString:
mssqlContainer.getConnectionUri(false),
databaseQuery: "SELECT 99 as value",
conditions: JSON.stringify([
{
type: "expression",
andOr: "and",
variable: "result",
operator: "equals",
value: "42",
},
]),
};
const heartbeat = {
msg: "",
status: PENDING,
};
try {
await assert.rejects(
mssqlMonitor.check(monitor, heartbeat, {}),
new Error(
"Query result did not meet the specified conditions (99)"
)
);
assert.strictEqual(
heartbeat.status,
PENDING,
`Expected status should not be ${heartbeat.status}`
);
} finally {
await mssqlContainer.stop();
}
});
test("check() rejects when query returns no results", async () => {
const mssqlContainer = await createAndStartMSSQLContainer();
const mssqlMonitor = new MssqlMonitorType();
const monitor = {
databaseConnectionString:
mssqlContainer.getConnectionUri(false),
databaseQuery: "SELECT 1 WHERE 1 = 0",
conditions: "[]",
};
const heartbeat = {
msg: "",
status: PENDING,
};
try {
await assert.rejects(
mssqlMonitor.check(monitor, heartbeat, {}),
new Error(
"Database connection/query failed: Query returned no results"
)
);
assert.strictEqual(
heartbeat.status,
PENDING,
`Expected status should not be ${heartbeat.status}`
);
} finally {
await mssqlContainer.stop();
}
});
test("check() rejects when query returns multiple rows", async () => {
const mssqlContainer = await createAndStartMSSQLContainer();
const mssqlMonitor = new MssqlMonitorType();
const monitor = {
databaseConnectionString:
mssqlContainer.getConnectionUri(false),
databaseQuery: "SELECT 1 UNION ALL SELECT 2",
conditions: "[]",
};
const heartbeat = {
msg: "",
status: PENDING,
};
try {
await assert.rejects(
mssqlMonitor.check(monitor, heartbeat, {}),
new Error(
"Database connection/query failed: Multiple values were found, expected only one value"
)
);
assert.strictEqual(
heartbeat.status,
PENDING,
`Expected status should not be ${heartbeat.status}`
);
} finally {
await mssqlContainer.stop();
}
});
test("check() rejects when query returns multiple columns", async () => {
const mssqlContainer = await createAndStartMSSQLContainer();
const mssqlMonitor = new MssqlMonitorType();
const monitor = {
databaseConnectionString:
mssqlContainer.getConnectionUri(false),
databaseQuery: "SELECT 1 AS col1, 2 AS col2",
conditions: "[]",
};
const heartbeat = {
msg: "",
status: PENDING,
};
try {
await assert.rejects(
mssqlMonitor.check(monitor, heartbeat, {}),
new Error(
"Database connection/query failed: Multiple columns were found, expected only one value"
)
);
assert.strictEqual(
heartbeat.status,
PENDING,
`Expected status should not be ${heartbeat.status}`
);
} finally {
await mssqlContainer.stop();
}
});
test("check() rejects when MSSQL server is not reachable", async () => {
const mssqlMonitor = new MssqlMonitorType();
const monitor = {
databaseConnectionString:
"Server=localhost,15433;Database=master;User Id=Fail;Password=Fail;Encrypt=false",
conditions: "[]",
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
mssqlMonitor.check(monitor, heartbeat, {}),
new Error(
"Database connection/query failed: Failed to connect to localhost:15433 - Could not connect (sequence)"
)
);
assert.notStrictEqual(
heartbeat.status,
UP,
`Expected status should not be ${heartbeat.status}`
);
});
}
);

8
test/backend-test/test-postgres.js → test/backend-test/monitors/test-postgres.js
View File

@@ -1,8 +1,8 @@
const { describe, test } = require("node:test");
const assert = require("node:assert");
const { PostgreSqlContainer } = require("@testcontainers/postgresql");
const { PostgresMonitorType } = require("../../server/monitor-types/postgres");
const { UP, PENDING } = require("../../src/util");
const { PostgresMonitorType } = require("../../../server/monitor-types/postgres");
const { UP, PENDING } = require("../../../src/util");
describe(
"Postgres Single Node",
@@ -12,7 +12,7 @@ describe(
(process.platform !== "linux" || process.arch !== "x64"),
},
() => {
test("Postgres is running", async () => {
test("check() sets status to UP when Postgres server is reachable", async () => {
// The default timeout of 30 seconds might not be enough for the container to start
const postgresContainer = await new PostgreSqlContainer(
"postgres:latest"
@@ -37,7 +37,7 @@ describe(
}
});
test("Postgres is not running", async () => {
test("check() rejects when Postgres server is not reachable", async () => {
const postgresMonitor = new PostgresMonitorType();
const monitor = {
databaseConnectionString: "http://localhost:15432",

8
test/backend-test/test-rabbitmq.js → test/backend-test/monitors/test-rabbitmq.js
View File

@@ -1,13 +1,13 @@
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");
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("RabbitMQ is running", async () => {
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();
@@ -33,7 +33,7 @@ describe("RabbitMQ Single Node", {
}
});
test("RabbitMQ is not running", async () => {
test("check() rejects when RabbitMQ server is not reachable", async () => {
const rabbitMQMonitor = new RabbitMqMonitorType();
const monitor = {
rabbitmqNodes: JSON.stringify([ "http://localhost:15672" ]),

35
test/backend-test/test-tcp.js → test/backend-test/monitors/test-tcp.js
View File

@@ -1,14 +1,9 @@
const { describe, test } = require("node:test");
const assert = require("node:assert");
const { TCPMonitorType } = require("../../server/monitor-types/tcp");
const { UP, PENDING } = require("../../src/util");
const { TCPMonitorType } = require("../../../server/monitor-types/tcp");
const { UP, PENDING } = require("../../../src/util");
const net = require("net");
/**
* Test suite for TCP Monitor functionality
* This test suite checks the behavior of the TCPMonitorType class
* under different network connection scenarios.
*/
describe("TCP Monitor", () => {
/**
* Creates a TCP server on a specified port
@@ -29,11 +24,7 @@ describe("TCP Monitor", () => {
});
}
/**
* Test case to verify TCP monitor works when a server is running
* Checks that the monitor correctly identifies an active TCP server
*/
test("TCP server is running", async () => {
test("check() sets status to UP when TCP server is reachable", async () => {
const port = 12345;
const server = await createTCPServer(port);
@@ -59,11 +50,7 @@ describe("TCP Monitor", () => {
}
});
/**
* Test case to verify TCP monitor handles non-running servers
* Checks that the monitor correctly identifies an inactive TCP server
*/
test("TCP server is not running", async () => {
test("check() rejects with connection failed when TCP server is not running", async () => {
const tcpMonitor = new TCPMonitorType();
const monitor = {
@@ -83,11 +70,7 @@ describe("TCP Monitor", () => {
);
});
/**
* Test case to verify TCP monitor handles servers with expired or invalid TLS certificates
* Checks that the monitor correctly identifies TLS certificate issues
*/
test("TCP server with expired or invalid TLS certificate", async t => {
test("check() rejects when TLS certificate is expired or invalid", async () => {
const tcpMonitor = new TCPMonitorType();
const monitor = {
@@ -114,7 +97,7 @@ describe("TCP Monitor", () => {
);
});
test("TCP server with valid TLS certificate (SSL)", async t => {
test("check() sets status to UP when TLS certificate is valid (SSL)", async () => {
const tcpMonitor = new TCPMonitorType();
const monitor = {
@@ -137,7 +120,7 @@ describe("TCP Monitor", () => {
assert.strictEqual(heartbeat.status, UP);
});
test("TCP server with valid TLS certificate (STARTTLS)", async t => {
test("check() sets status to UP when TLS certificate is valid (STARTTLS)", async () => {
const tcpMonitor = new TCPMonitorType();
const monitor = {
@@ -160,7 +143,7 @@ describe("TCP Monitor", () => {
assert.strictEqual(heartbeat.status, UP);
});
test("TCP server with valid but name mismatching TLS certificate (STARTTLS)", async t => {
test("check() rejects when TLS certificate hostname does not match (STARTTLS)", async () => {
const tcpMonitor = new TCPMonitorType();
const monitor = {
@@ -185,7 +168,7 @@ describe("TCP Monitor", () => {
regex
);
});
test("XMPP server with valid certificate (STARTTLS)", async t => {
test("check() sets status to UP for XMPP server with valid certificate (STARTTLS)", async () => {
const tcpMonitor = new TCPMonitorType();
const monitor = {

338
test/backend-test/monitors/test-websocket.js Normal file
View File

@@ -0,0 +1,338 @@
const { WebSocketServer } = require("ws");
const { describe, test } = require("node:test");
const assert = require("node:assert");
const { WebSocketMonitorType } = require("../../../server/monitor-types/websocket-upgrade");
const { UP, PENDING } = require("../../../src/util");
const net = require("node:net");
/**
* Simulates non compliant WS Server, doesnt send Sec-WebSocket-Accept header
* @param {number} port Port the server listens on. Defaults to 8080
* @returns {Promise} Promise that resolves to the created server once listening
*/
function nonCompliantWS(port = 8080) {
const srv = net.createServer((socket) => {
socket.once("data", (buf) => {
socket.write("HTTP/1.1 101 Switching Protocols\r\n" +
"Upgrade: websocket\r\n" +
"Connection: Upgrade\r\n\r\n");
socket.destroy();
});
});
return new Promise((resolve) => srv.listen(port, () => resolve(srv)));
}
describe("WebSocket Monitor", {
}, () => {
test("check() rejects with unexpected server response when connecting to non-WebSocket server", {}, async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://example.org",
wsIgnoreSecWebsocketAcceptHeader: false,
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
websocketMonitor.check(monitor, heartbeat, {}),
new Error("Unexpected server response: 200")
);
});
test("check() sets status to UP when connecting to secure WebSocket server", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://echo.websocket.org",
wsIgnoreSecWebsocketAcceptHeader: false,
accepted_statuscodes_json: JSON.stringify([ "1000" ]),
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
const expected = {
msg: "1000 - OK",
status: UP,
};
await websocketMonitor.check(monitor, heartbeat, {});
assert.deepStrictEqual(heartbeat, expected);
});
test("check() sets status to UP when connecting to insecure WebSocket server", async (t) => {
t.after(() => wss.close());
const websocketMonitor = new WebSocketMonitorType();
const wss = new WebSocketServer({ port: 8080 });
const monitor = {
url: "ws://localhost:8080",
wsIgnoreSecWebsocketAcceptHeader: false,
accepted_statuscodes_json: JSON.stringify([ "1000" ]),
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
const expected = {
msg: "1000 - OK",
status: UP,
};
await websocketMonitor.check(monitor, heartbeat, {});
assert.deepStrictEqual(heartbeat, expected);
});
test("check() rejects when status code does not match expected value", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://echo.websocket.org",
wsIgnoreSecWebsocketAcceptHeader: false,
accepted_statuscodes_json: JSON.stringify([ "1001" ]),
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
websocketMonitor.check(monitor, heartbeat, {}),
new Error("Unexpected status code: 1000")
);
});
test("check() rejects when expected status code is empty", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://echo.websocket.org",
wsIgnoreSecWebsocketAcceptHeader: false,
accepted_statuscodes_json: JSON.stringify([ "" ]),
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
websocketMonitor.check(monitor, heartbeat, {}),
new Error("Unexpected status code: 1000")
);
});
test("check() rejects when Sec-WebSocket-Accept header is invalid", async (t) => {
t.after(() => wss.close());
const websocketMonitor = new WebSocketMonitorType();
const wss = await nonCompliantWS();
const monitor = {
url: "ws://localhost:8080",
wsIgnoreSecWebsocketAcceptHeader: false,
accepted_statuscodes_json: JSON.stringify([ "1000" ]),
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
websocketMonitor.check(monitor, heartbeat, {}),
new Error("Invalid Sec-WebSocket-Accept header")
);
});
test("check() sets status to UP when ignoring invalid Sec-WebSocket-Accept header", async (t) => {
t.after(() => wss.close());
const websocketMonitor = new WebSocketMonitorType();
const wss = await nonCompliantWS();
const monitor = {
url: "ws://localhost:8080",
wsIgnoreSecWebsocketAcceptHeader: true,
accepted_statuscodes_json: JSON.stringify([ "1000" ]),
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
const expected = {
msg: "1000 - OK",
status: UP,
};
await websocketMonitor.check(monitor, heartbeat, {});
assert.deepStrictEqual(heartbeat, expected);
});
test("check() sets status to UP for compliant WebSocket server when ignoring Sec-WebSocket-Accept", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://echo.websocket.org",
wsIgnoreSecWebsocketAcceptHeader: true,
accepted_statuscodes_json: JSON.stringify([ "1000" ]),
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
const expected = {
msg: "1000 - OK",
status: UP,
};
await websocketMonitor.check(monitor, heartbeat, {});
assert.deepStrictEqual(heartbeat, expected);
});
test("check() rejects non-WebSocket server even when ignoring Sec-WebSocket-Accept", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://example.org",
wsIgnoreSecWebsocketAcceptHeader: true,
accepted_statuscodes_json: JSON.stringify([ "1000" ]),
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
websocketMonitor.check(monitor, heartbeat, {}),
new Error("Unexpected server response: 200")
);
});
test("check() rejects when server does not support requested subprotocol", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://echo.websocket.org",
wsIgnoreSecWebsocketAcceptHeader: false,
wsSubprotocol: "ocpp1.6",
accepted_statuscodes_json: JSON.stringify([ "1000" ]),
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
websocketMonitor.check(monitor, heartbeat, {}),
new Error("Server sent no subprotocol")
);
});
test("check() rejects when multiple subprotocols contain invalid characters", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://echo.websocket.org",
wsIgnoreSecWebsocketAcceptHeader: false,
wsSubprotocol: " # & ,ocpp2.0 [] , ocpp1.6 , ,, ; ",
accepted_statuscodes_json: JSON.stringify([ "1000" ]),
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
websocketMonitor.check(monitor, heartbeat, {}),
new SyntaxError("An invalid or duplicated subprotocol was specified")
);
});
test("check() sets status to UP when subprotocol with multiple spaces is accepted", async (t) => {
t.after(() => wss.close());
const websocketMonitor = new WebSocketMonitorType();
const wss = new WebSocketServer({ port: 8080,
handleProtocols: (protocols) => {
return Array.from(protocols).includes("test") ? "test" : null;
}
});
const monitor = {
url: "ws://localhost:8080",
wsIgnoreSecWebsocketAcceptHeader: false,
wsSubprotocol: "invalid , test ",
accepted_statuscodes_json: JSON.stringify([ "1000" ]),
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
const expected = {
msg: "1000 - OK",
status: UP,
};
await websocketMonitor.check(monitor, heartbeat, {});
assert.deepStrictEqual(heartbeat, expected);
});
test("check() sets status to UP when server supports requested subprotocol", async (t) => {
t.after(() => wss.close());
const websocketMonitor = new WebSocketMonitorType();
const wss = new WebSocketServer({ port: 8080,
handleProtocols: (protocols) => {
return Array.from(protocols).includes("test") ? "test" : null;
}
});
const monitor = {
url: "ws://localhost:8080",
wsIgnoreSecWebsocketAcceptHeader: false,
wsSubprotocol: "invalid,test",
accepted_statuscodes_json: JSON.stringify([ "1000" ]),
timeout: 30,
};
const heartbeat = {
msg: "",
status: PENDING,
};
const expected = {
msg: "1000 - OK",
status: UP,
};
await websocketMonitor.check(monitor, heartbeat, {});
assert.deepStrictEqual(heartbeat, expected);
});
});

56
test/mock-webhook.js → test/backend-test/notification-providers/mock-webhook.js
View File

@@ -1,28 +1,28 @@
const express = require("express");
const bodyParser = require("body-parser");
/**
* @param {number} port Port number
* @param {string} url Webhook URL
* @param {number} timeout Timeout
* @returns {Promise<object>} Webhook data
*/
async function mockWebhook(port, url, timeout = 2500) {
return new Promise((resolve, reject) => {
const app = express();
const tmo = setTimeout(() => {
server.close();
reject({ reason: "Timeout" });
}, timeout);
app.use(bodyParser.json()); // Middleware to parse JSON bodies
app.post(`/${url}`, (req, res) => {
res.status(200).send("OK");
server.close();
tmo && clearTimeout(tmo);
resolve(req.body);
});
const server = app.listen(port);
});
}
module.exports = mockWebhook;
const express = require("express");
const bodyParser = require("body-parser");
/**
* @param {number} port Port number
* @param {string} url Webhook URL
* @param {number} timeout Timeout
* @returns {Promise<object>} Webhook data
*/
async function mockWebhook(port, url, timeout = 2500) {
return new Promise((resolve, reject) => {
const app = express();
const tmo = setTimeout(() => {
server.close();
reject({ reason: "Timeout" });
}, timeout);
app.use(bodyParser.json()); // Middleware to parse JSON bodies
app.post(`/${url}`, (req, res) => {
res.status(200).send("OK");
server.close();
tmo && clearTimeout(tmo);
resolve(req.body);
});
const server = app.listen(port);
});
}
module.exports = mockWebhook;

18
test/backend-test/test-cert-hostname-match.js
View File

@@ -1,4 +1,4 @@
const { test } = require("node:test");
const { describe, test } = require("node:test");
const assert = require("node:assert");
@@ -36,12 +36,14 @@ iPenGDCg1awOyRnvxNq1MtMDkR9AHwksukzwiYNexYjyvE2t0UzXhFXwazQ3
-----END CERTIFICATE-----
`;
test("Certificate and hostname match", () => {
const result = checkCertificateHostname(testCert, "www.eff.org");
assert.strictEqual(result, true);
});
describe("Certificate Hostname Validation", () => {
test("checkCertificateHostname() returns true when certificate matches hostname", () => {
const result = checkCertificateHostname(testCert, "www.eff.org");
assert.strictEqual(result, true);
});
test("Certificate and hostname mismatch", () => {
const result = checkCertificateHostname(testCert, "example.com");
assert.strictEqual(result, false);
test("checkCertificateHostname() returns false when certificate does not match hostname", () => {
const result = checkCertificateHostname(testCert, "example.com");
assert.strictEqual(result, false);
});
});

41
test/backend-test/test-domain.js
View File

@@ -1,9 +1,9 @@
process.env.UPTIME_KUMA_HIDE_LOG = [ "info_db", "info_server" ].join(",");
const test = require("node:test");
const { describe, test } = require("node:test");
const assert = require("node:assert");
const DomainExpiry = require("../../server/model/domain_expiry");
const mockWebhook = require("../mock-webhook");
const mockWebhook = require("./notification-providers/mock-webhook");
const TestDB = require("../mock-testdb");
const { R } = require("redbean-node");
const { Notification } = require("../../server/notification");
@@ -12,30 +12,34 @@ const { setSetting } = require("../../server/util-server");
const testDb = new TestDB();
test("Domain Expiry", async (t) => {
await testDb.create();
Notification.init();
describe("Domain Expiry", () => {
const monHttpCom = {
type: "http",
url: "https://www.google.com",
domainExpiryNotification: true
};
await t.test("Should get expiry date for .wiki with no A record", async () => {
test("getExpiryDate() returns correct expiry date for .wiki domain with no A record", async () => {
await testDb.create();
Notification.init();
const d = DomainExpiry.createByName("google.wiki");
assert.deepEqual(await d.getExpiryDate(), new Date("2026-11-26T23:59:59.000Z"));
});
await t.test("Should get expiration date for .com from RDAP", async () => {
test("forMonitor() retrieves expiration date for .com domain from RDAP", async () => {
const domain = await DomainExpiry.forMonitor(monHttpCom);
const expiryFromRdap = await domain.getExpiryDate(); // from RDAP
assert.deepEqual(expiryFromRdap, new Date("2028-09-14T04:00:00.000Z"));
});
await t.test("Should have expiration date cached in database", async () => {
test("checkExpiry() caches expiration date in database", async () => {
await DomainExpiry.checkExpiry(monHttpCom); // RDAP -> Cache
const domain = await DomainExpiry.findByName("google.com");
assert(Date.now() - domain.lastCheck < 5 * 1000);
});
await t.test("Should trigger notify for expiring domain", async () => {
test("sendNotifications() triggers notification for expiring domain", async () => {
await DomainExpiry.findByName("google.com");
const hook = {
"port": 3010,
@@ -53,18 +57,17 @@ test("Domain Expiry", async (t) => {
"user_id": 1,
"name": "Testhook"
});
const manyDays = 1500;
setSetting("domainExpiryNotifyDays", [ 7, 14, manyDays ], "general");
const [ notifRet, data ] = await Promise.all([
const manyDays = 3650;
setSetting("domainExpiryNotifyDays", [ manyDays ], "general");
const [ , data ] = await Promise.all([
DomainExpiry.sendNotifications(monHttpCom, [ notif ]),
mockWebhook(hook.port, hook.url)
]);
assert.equal(notifRet, manyDays);
assert.match(data.msg, /will expire in/);
setTimeout(async () => {
Settings.stopCacheCleaner();
await testDb.destroy();
}, 200);
});
}).finally(() => {
setTimeout(async () => {
Settings.stopCacheCleaner();
await testDb.destroy();
}, 200);
});

65
test/backend-test/test-maintenance.js
View File

@@ -1,65 +0,0 @@
const test = require("node:test");
const assert = require("node:assert");
const dayjs = require("dayjs");
const { SQL_DATETIME_FORMAT } = require("../../src/util");
dayjs.extend(require("dayjs/plugin/utc"));
dayjs.extend(require("dayjs/plugin/customParseFormat"));
/**
* Tests for maintenance date formatting to ensure compatibility with MariaDB/MySQL.
* Issue: MariaDB rejects ISO format dates like '2025-12-19T01:04:02.129Z'
* Fix: Use SQL_DATETIME_FORMAT ('YYYY-MM-DD HH:mm:ss') instead of toISOString()
*/
test("Maintenance Date Format - MariaDB Compatibility", async (t) => {
await t.test("SQL_DATETIME_FORMAT constant should match MariaDB format", async () => {
assert.strictEqual(SQL_DATETIME_FORMAT, "YYYY-MM-DD HH:mm:ss");
});
await t.test("Format date using SQL_DATETIME_FORMAT", async () => {
const current = dayjs.utc("2025-12-19T01:04:02.129Z");
const sqlFormat = current.utc().format(SQL_DATETIME_FORMAT);
assert.strictEqual(sqlFormat, "2025-12-19 01:04:02");
});
await t.test("SQL format should not contain ISO markers (T, Z)", async () => {
const current = dayjs.utc("2025-12-19T01:04:02.129Z");
const sqlFormat = current.utc().format(SQL_DATETIME_FORMAT);
assert.strictEqual(sqlFormat.includes("T"), false, "SQL format should not contain 'T'");
assert.strictEqual(sqlFormat.includes("Z"), false, "SQL format should not contain 'Z'");
});
await t.test("SQL format should match YYYY-MM-DD HH:mm:ss pattern", async () => {
const current = dayjs.utc("2025-12-19T01:04:02.129Z");
const sqlFormat = current.utc().format(SQL_DATETIME_FORMAT);
const sqlDateTimeRegex = /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/;
assert.strictEqual(sqlDateTimeRegex.test(sqlFormat), true);
});
await t.test("Parse SQL datetime back to dayjs preserves timestamp", async () => {
const originalDate = dayjs.utc("2025-12-19T01:04:02.000Z");
const sqlFormat = originalDate.utc().format(SQL_DATETIME_FORMAT);
const parsedDate = dayjs.utc(sqlFormat, SQL_DATETIME_FORMAT);
assert.strictEqual(parsedDate.unix(), originalDate.unix());
});
await t.test("Edge case: midnight timestamp", async () => {
const midnight = dayjs.utc("2025-01-01T00:00:00.000Z");
const sqlFormat = midnight.utc().format(SQL_DATETIME_FORMAT);
assert.strictEqual(sqlFormat, "2025-01-01 00:00:00");
});
await t.test("Edge case: end of day timestamp", async () => {
const endOfDay = dayjs.utc("2025-12-31T23:59:59.999Z");
const sqlFormat = endOfDay.utc().format(SQL_DATETIME_FORMAT);
assert.strictEqual(sqlFormat, "2025-12-31 23:59:59");
});
});

6
test/backend-test/test-migration.js
View File

@@ -3,8 +3,8 @@ const fs = require("fs");
const path = require("path");
const { GenericContainer, Wait } = require("testcontainers");
describe("Database Migration - Optimize Important Indexes", () => {
test("SQLite: All migrations run successfully", async () => {
describe("Database Migration", () => {
test("SQLite migrations run successfully from fresh database", async () => {
const testDbPath = path.join(__dirname, "../../data/test-migration.db");
const testDbDir = path.dirname(testDbPath);
@@ -57,7 +57,7 @@ describe("Database Migration - Optimize Important Indexes", () => {
});
test(
"MariaDB: All migrations run successfully",
"MariaDB migrations run successfully from fresh database",
{
skip:
!!process.env.CI &&

680
test/backend-test/test-uptime-calculator.js
View File

@@ -1,4 +1,4 @@
const test = require("node:test");
const { describe, test } = require("node:test");
const assert = require("node:assert");
const { UptimeCalculator } = require("../../server/uptime-calculator");
const dayjs = require("dayjs");
@@ -7,344 +7,403 @@ dayjs.extend(require("dayjs/plugin/utc"));
dayjs.extend(require("../../server/modules/dayjs/plugin/timezone"));
dayjs.extend(require("dayjs/plugin/customParseFormat"));
test("Test Uptime Calculator - custom date", async (t) => {
let c1 = new UptimeCalculator();
describe("Uptime Calculator", () => {
test("getCurrentDate() returns custom date when set", () => {
let c1 = new UptimeCalculator();
// Test custom date
UptimeCalculator.currentDate = dayjs.utc("2021-01-01T00:00:00.000Z");
assert.strictEqual(c1.getCurrentDate().unix(), dayjs.utc("2021-01-01T00:00:00.000Z").unix());
});
// Test custom date
UptimeCalculator.currentDate = dayjs.utc("2021-01-01T00:00:00.000Z");
assert.strictEqual(c1.getCurrentDate().unix(), dayjs.utc("2021-01-01T00:00:00.000Z").unix());
});
test("Test update - UP", async (t) => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:46:59");
let c2 = new UptimeCalculator();
let date = await c2.update(UP);
assert.strictEqual(date.unix(), dayjs.utc("2023-08-12 20:46:59").unix());
});
test("update() with UP status returns correct timestamp", async () => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:46:59");
let c2 = new UptimeCalculator();
let date = await c2.update(UP);
assert.strictEqual(date.unix(), dayjs.utc("2023-08-12 20:46:59").unix());
});
test("Test update - MAINTENANCE", async (t) => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:47:20");
let c2 = new UptimeCalculator();
let date = await c2.update(MAINTENANCE);
assert.strictEqual(date.unix(), dayjs.utc("2023-08-12 20:47:20").unix());
});
test("update() with MAINTENANCE status returns correct timestamp", async () => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:47:20");
let c2 = new UptimeCalculator();
let date = await c2.update(MAINTENANCE);
assert.strictEqual(date.unix(), dayjs.utc("2023-08-12 20:47:20").unix());
});
test("Test update - DOWN", async (t) => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:47:20");
let c2 = new UptimeCalculator();
let date = await c2.update(DOWN);
assert.strictEqual(date.unix(), dayjs.utc("2023-08-12 20:47:20").unix());
});
test("update() with DOWN status returns correct timestamp", async () => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:47:20");
let c2 = new UptimeCalculator();
let date = await c2.update(DOWN);
assert.strictEqual(date.unix(), dayjs.utc("2023-08-12 20:47:20").unix());
});
test("Test update - PENDING", async (t) => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:47:20");
let c2 = new UptimeCalculator();
let date = await c2.update(PENDING);
assert.strictEqual(date.unix(), dayjs.utc("2023-08-12 20:47:20").unix());
});
test("update() with PENDING status returns correct timestamp", async () => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:47:20");
let c2 = new UptimeCalculator();
let date = await c2.update(PENDING);
assert.strictEqual(date.unix(), dayjs.utc("2023-08-12 20:47:20").unix());
});
test("Test flatStatus", async (t) => {
let c2 = new UptimeCalculator();
assert.strictEqual(c2.flatStatus(UP), UP);
//assert.strictEqual(c2.flatStatus(MAINTENANCE), UP);
assert.strictEqual(c2.flatStatus(DOWN), DOWN);
assert.strictEqual(c2.flatStatus(PENDING), DOWN);
});
test("flatStatus() converts statuses correctly", () => {
let c2 = new UptimeCalculator();
assert.strictEqual(c2.flatStatus(UP), UP);
//assert.strictEqual(c2.flatStatus(MAINTENANCE), UP);
assert.strictEqual(c2.flatStatus(DOWN), DOWN);
assert.strictEqual(c2.flatStatus(PENDING), DOWN);
});
test("Test getMinutelyKey", async (t) => {
let c2 = new UptimeCalculator();
let divisionKey = c2.getMinutelyKey(dayjs.utc("2023-08-12 20:46:00"));
assert.strictEqual(divisionKey, dayjs.utc("2023-08-12 20:46:00").unix());
test("getMinutelyKey() returns correct timestamp for start of minute", () => {
let c2 = new UptimeCalculator();
let divisionKey = c2.getMinutelyKey(dayjs.utc("2023-08-12 20:46:00"));
assert.strictEqual(divisionKey, dayjs.utc("2023-08-12 20:46:00").unix());
// Edge case 1
c2 = new UptimeCalculator();
divisionKey = c2.getMinutelyKey(dayjs.utc("2023-08-12 20:46:01"));
assert.strictEqual(divisionKey, dayjs.utc("2023-08-12 20:46:00").unix());
// Edge case 1
c2 = new UptimeCalculator();
divisionKey = c2.getMinutelyKey(dayjs.utc("2023-08-12 20:46:01"));
assert.strictEqual(divisionKey, dayjs.utc("2023-08-12 20:46:00").unix());
// Edge case 2
c2 = new UptimeCalculator();
divisionKey = c2.getMinutelyKey(dayjs.utc("2023-08-12 20:46:59"));
assert.strictEqual(divisionKey, dayjs.utc("2023-08-12 20:46:00").unix());
});
// Edge case 2
c2 = new UptimeCalculator();
divisionKey = c2.getMinutelyKey(dayjs.utc("2023-08-12 20:46:59"));
assert.strictEqual(divisionKey, dayjs.utc("2023-08-12 20:46:00").unix());
});
test("Test getDailyKey", async (t) => {
let c2 = new UptimeCalculator();
let dailyKey = c2.getDailyKey(dayjs.utc("2023-08-12 20:46:00"));
assert.strictEqual(dailyKey, dayjs.utc("2023-08-12").unix());
test("getDailyKey() returns correct timestamp for start of day", () => {
let c2 = new UptimeCalculator();
let dailyKey = c2.getDailyKey(dayjs.utc("2023-08-12 20:46:00"));
assert.strictEqual(dailyKey, dayjs.utc("2023-08-12").unix());
c2 = new UptimeCalculator();
dailyKey = c2.getDailyKey(dayjs.utc("2023-08-12 23:45:30"));
assert.strictEqual(dailyKey, dayjs.utc("2023-08-12").unix());
c2 = new UptimeCalculator();
dailyKey = c2.getDailyKey(dayjs.utc("2023-08-12 23:45:30"));
assert.strictEqual(dailyKey, dayjs.utc("2023-08-12").unix());
// Edge case 1
c2 = new UptimeCalculator();
dailyKey = c2.getDailyKey(dayjs.utc("2023-08-12 23:59:59"));
assert.strictEqual(dailyKey, dayjs.utc("2023-08-12").unix());
// Edge case 1
c2 = new UptimeCalculator();
dailyKey = c2.getDailyKey(dayjs.utc("2023-08-12 23:59:59"));
assert.strictEqual(dailyKey, dayjs.utc("2023-08-12").unix());
// Edge case 2
c2 = new UptimeCalculator();
dailyKey = c2.getDailyKey(dayjs.utc("2023-08-12 00:00:00"));
assert.strictEqual(dailyKey, dayjs.utc("2023-08-12").unix());
// Edge case 2
c2 = new UptimeCalculator();
dailyKey = c2.getDailyKey(dayjs.utc("2023-08-12 00:00:00"));
assert.strictEqual(dailyKey, dayjs.utc("2023-08-12").unix());
// Test timezone
c2 = new UptimeCalculator();
dailyKey = c2.getDailyKey(dayjs("Sat Dec 23 2023 05:38:39 GMT+0800 (Hong Kong Standard Time)"));
assert.strictEqual(dailyKey, dayjs.utc("2023-12-22").unix());
});
// Test timezone
c2 = new UptimeCalculator();
dailyKey = c2.getDailyKey(dayjs("Sat Dec 23 2023 05:38:39 GMT+0800 (Hong Kong Standard Time)"));
assert.strictEqual(dailyKey, dayjs.utc("2023-12-22").unix());
});
test("Test lastDailyUptimeData", async (t) => {
let c2 = new UptimeCalculator();
await c2.update(UP);
assert.strictEqual(c2.lastDailyUptimeData.up, 1);
});
test("lastDailyUptimeData tracks UP status correctly", async () => {
let c2 = new UptimeCalculator();
await c2.update(UP);
assert.strictEqual(c2.lastDailyUptimeData.up, 1);
});
test("Test get24Hour Uptime and Avg Ping", async (t) => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:46:59");
test("get24Hour() calculates uptime and average ping correctly", async () => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:46:59");
// No data
let c2 = new UptimeCalculator();
let data = c2.get24Hour();
assert.strictEqual(data.uptime, 0);
assert.strictEqual(data.avgPing, null);
// No data
let c2 = new UptimeCalculator();
let data = c2.get24Hour();
assert.strictEqual(data.uptime, 0);
assert.strictEqual(data.avgPing, null);
// 1 Up
c2 = new UptimeCalculator();
await c2.update(UP, 100);
let uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 1);
assert.strictEqual(c2.get24Hour().avgPing, 100);
// 1 Up
c2 = new UptimeCalculator();
await c2.update(UP, 100);
let uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 1);
assert.strictEqual(c2.get24Hour().avgPing, 100);
// 2 Up
c2 = new UptimeCalculator();
await c2.update(UP, 100);
await c2.update(UP, 200);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 1);
assert.strictEqual(c2.get24Hour().avgPing, 150);
// 2 Up
c2 = new UptimeCalculator();
await c2.update(UP, 100);
await c2.update(UP, 200);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 1);
assert.strictEqual(c2.get24Hour().avgPing, 150);
// 3 Up
c2 = new UptimeCalculator();
await c2.update(UP, 0);
await c2.update(UP, 100);
await c2.update(UP, 400);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 1);
assert.strictEqual(c2.get24Hour().avgPing, 166.66666666666666);
// 3 Up
c2 = new UptimeCalculator();
await c2.update(UP, 0);
await c2.update(UP, 100);
await c2.update(UP, 400);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 1);
assert.strictEqual(c2.get24Hour().avgPing, 166.66666666666666);
// 1 MAINTENANCE
c2 = new UptimeCalculator();
await c2.update(MAINTENANCE);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0);
assert.strictEqual(c2.get24Hour().avgPing, null);
// 1 MAINTENANCE
c2 = new UptimeCalculator();
await c2.update(MAINTENANCE);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0);
assert.strictEqual(c2.get24Hour().avgPing, null);
// 1 PENDING
c2 = new UptimeCalculator();
await c2.update(PENDING);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0);
assert.strictEqual(c2.get24Hour().avgPing, null);
// 1 PENDING
c2 = new UptimeCalculator();
await c2.update(PENDING);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0);
assert.strictEqual(c2.get24Hour().avgPing, null);
// 1 DOWN
c2 = new UptimeCalculator();
await c2.update(DOWN);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0);
assert.strictEqual(c2.get24Hour().avgPing, null);
// 1 DOWN
c2 = new UptimeCalculator();
await c2.update(DOWN);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0);
assert.strictEqual(c2.get24Hour().avgPing, null);
// 2 DOWN
c2 = new UptimeCalculator();
await c2.update(DOWN);
await c2.update(DOWN);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0);
assert.strictEqual(c2.get24Hour().avgPing, null);
// 2 DOWN
c2 = new UptimeCalculator();
await c2.update(DOWN);
await c2.update(DOWN);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0);
assert.strictEqual(c2.get24Hour().avgPing, null);
// 1 DOWN, 1 UP
c2 = new UptimeCalculator();
await c2.update(DOWN);
await c2.update(UP, 0.5);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0.5);
assert.strictEqual(c2.get24Hour().avgPing, 0.5);
// 1 DOWN, 1 UP
c2 = new UptimeCalculator();
await c2.update(DOWN);
await c2.update(UP, 0.5);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0.5);
assert.strictEqual(c2.get24Hour().avgPing, 0.5);
// 1 UP, 1 DOWN
c2 = new UptimeCalculator();
await c2.update(UP, 123);
await c2.update(DOWN);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0.5);
assert.strictEqual(c2.get24Hour().avgPing, 123);
// 1 UP, 1 DOWN
c2 = new UptimeCalculator();
await c2.update(UP, 123);
await c2.update(DOWN);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0.5);
assert.strictEqual(c2.get24Hour().avgPing, 123);
// Add 24 hours
c2 = new UptimeCalculator();
await c2.update(UP, 0);
await c2.update(UP, 0);
await c2.update(UP, 0);
await c2.update(UP, 1);
await c2.update(DOWN);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0.8);
assert.strictEqual(c2.get24Hour().avgPing, 0.25);
// Add 24 hours
c2 = new UptimeCalculator();
await c2.update(UP, 0);
await c2.update(UP, 0);
await c2.update(UP, 0);
await c2.update(UP, 1);
await c2.update(DOWN);
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0.8);
assert.strictEqual(c2.get24Hour().avgPing, 0.25);
UptimeCalculator.currentDate = UptimeCalculator.currentDate.add(24, "hour");
UptimeCalculator.currentDate = UptimeCalculator.currentDate.add(24, "hour");
// After 24 hours, even if there is no data, the uptime should be still 80%
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0.8);
assert.strictEqual(c2.get24Hour().avgPing, 0.25);
// After 24 hours, even if there is no data, the uptime should be still 80%
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0.8);
assert.strictEqual(c2.get24Hour().avgPing, 0.25);
// Add more 24 hours (48 hours)
UptimeCalculator.currentDate = UptimeCalculator.currentDate.add(24, "hour");
// Add more 24 hours (48 hours)
UptimeCalculator.currentDate = UptimeCalculator.currentDate.add(24, "hour");
// After 48 hours, even if there is no data, the uptime should be still 80%
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0.8);
assert.strictEqual(c2.get24Hour().avgPing, 0.25);
});
// After 48 hours, even if there is no data, the uptime should be still 80%
uptime = c2.get24Hour().uptime;
assert.strictEqual(uptime, 0.8);
assert.strictEqual(c2.get24Hour().avgPing, 0.25);
});
test("Test get7DayUptime", async (t) => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:46:59");
test("get7Day() calculates 7-day uptime correctly", async () => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:46:59");
// No data
let c2 = new UptimeCalculator();
let uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0);
// No data
let c2 = new UptimeCalculator();
let uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0);
// 1 Up
c2 = new UptimeCalculator();
await c2.update(UP);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 1);
// 1 Up
c2 = new UptimeCalculator();
await c2.update(UP);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 1);
// 2 Up
c2 = new UptimeCalculator();
await c2.update(UP);
await c2.update(UP);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 1);
// 2 Up
c2 = new UptimeCalculator();
await c2.update(UP);
await c2.update(UP);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 1);
// 3 Up
c2 = new UptimeCalculator();
await c2.update(UP);
await c2.update(UP);
await c2.update(UP);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 1);
// 3 Up
c2 = new UptimeCalculator();
await c2.update(UP);
await c2.update(UP);
await c2.update(UP);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 1);
// 1 MAINTENANCE
c2 = new UptimeCalculator();
await c2.update(MAINTENANCE);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0);
// 1 MAINTENANCE
c2 = new UptimeCalculator();
await c2.update(MAINTENANCE);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0);
// 1 PENDING
c2 = new UptimeCalculator();
await c2.update(PENDING);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0);
// 1 PENDING
c2 = new UptimeCalculator();
await c2.update(PENDING);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0);
// 1 DOWN
c2 = new UptimeCalculator();
await c2.update(DOWN);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0);
// 1 DOWN
c2 = new UptimeCalculator();
await c2.update(DOWN);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0);
// 2 DOWN
c2 = new UptimeCalculator();
await c2.update(DOWN);
await c2.update(DOWN);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0);
// 2 DOWN
c2 = new UptimeCalculator();
await c2.update(DOWN);
await c2.update(DOWN);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0);
// 1 DOWN, 1 UP
c2 = new UptimeCalculator();
await c2.update(DOWN);
await c2.update(UP);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0.5);
// 1 DOWN, 1 UP
c2 = new UptimeCalculator();
await c2.update(DOWN);
await c2.update(UP);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0.5);
// 1 UP, 1 DOWN
c2 = new UptimeCalculator();
await c2.update(UP);
await c2.update(DOWN);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0.5);
// 1 UP, 1 DOWN
c2 = new UptimeCalculator();
await c2.update(UP);
await c2.update(DOWN);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0.5);
// Add 7 days
c2 = new UptimeCalculator();
await c2.update(UP);
await c2.update(UP);
await c2.update(UP);
await c2.update(UP);
await c2.update(DOWN);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0.8);
UptimeCalculator.currentDate = UptimeCalculator.currentDate.add(7, "day");
// Add 7 days
c2 = new UptimeCalculator();
await c2.update(UP);
await c2.update(UP);
await c2.update(UP);
await c2.update(UP);
await c2.update(DOWN);
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0.8);
UptimeCalculator.currentDate = UptimeCalculator.currentDate.add(7, "day");
// After 7 days, even if there is no data, the uptime should be still 80%
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0.8);
// After 7 days, even if there is no data, the uptime should be still 80%
uptime = c2.get7Day().uptime;
assert.strictEqual(uptime, 0.8);
});
});
test("get30Day() calculates 30-day uptime correctly with 1 check per day", async () => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:46:59");
test("Test get30DayUptime (1 check per day)", async (t) => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:46:59");
let c2 = new UptimeCalculator();
let uptime = c2.get30Day().uptime;
assert.strictEqual(uptime, 0);
let c2 = new UptimeCalculator();
let uptime = c2.get30Day().uptime;
assert.strictEqual(uptime, 0);
let up = 0;
let down = 0;
let flip = true;
for (let i = 0; i < 30; i++) {
UptimeCalculator.currentDate = UptimeCalculator.currentDate.add(1, "day");
let up = 0;
let down = 0;
let flip = true;
for (let i = 0; i < 30; i++) {
UptimeCalculator.currentDate = UptimeCalculator.currentDate.add(1, "day");
if (flip) {
await c2.update(UP);
up++;
} else {
await c2.update(DOWN);
down++;
}
if (flip) {
await c2.update(UP);
up++;
} else {
await c2.update(DOWN);
down++;
uptime = c2.get30Day().uptime;
assert.strictEqual(uptime, up / (up + down));
flip = !flip;
}
uptime = c2.get30Day().uptime;
assert.strictEqual(uptime, up / (up + down));
// Last 7 days
// Down, Up, Down, Up, Down, Up, Down
// So 3 UP
assert.strictEqual(c2.get7Day().uptime, 3 / 7);
});
flip = !flip;
}
test("get1Year() calculates 1-year uptime correctly with 1 check per day", async () => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:46:59");
// Last 7 days
// Down, Up, Down, Up, Down, Up, Down
// So 3 UP
assert.strictEqual(c2.get7Day().uptime, 3 / 7);
});
let c2 = new UptimeCalculator();
let uptime = c2.get1Year().uptime;
assert.strictEqual(uptime, 0);
test("Test get1YearUptime (1 check per day)", async (t) => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:46:59");
let flip = true;
for (let i = 0; i < 365; i++) {
UptimeCalculator.currentDate = UptimeCalculator.currentDate.add(1, "day");
let c2 = new UptimeCalculator();
let uptime = c2.get1Year().uptime;
assert.strictEqual(uptime, 0);
if (flip) {
await c2.update(UP);
} else {
await c2.update(DOWN);
}
let flip = true;
for (let i = 0; i < 365; i++) {
UptimeCalculator.currentDate = UptimeCalculator.currentDate.add(1, "day");
if (flip) {
await c2.update(UP);
} else {
await c2.update(DOWN);
uptime = c2.get30Day().time;
flip = !flip;
}
uptime = c2.get30Day().time;
flip = !flip;
}
assert.strictEqual(c2.get1Year().uptime, 183 / 365);
assert.strictEqual(c2.get30Day().uptime, 15 / 30);
assert.strictEqual(c2.get7Day().uptime, 4 / 7);
});
assert.strictEqual(c2.get1Year().uptime, 183 / 365);
assert.strictEqual(c2.get30Day().uptime, 15 / 30);
assert.strictEqual(c2.get7Day().uptime, 4 / 7);
describe("Worst case scenario", () => {
test("handles year-long simulation with various statuses", {
skip: process.env.GITHUB_ACTIONS // Not stable on GitHub Actions"
}, async (t) => {
console.log("Memory usage before preparation", memoryUsage());
let c = new UptimeCalculator();
let up = 0;
let down = 0;
let interval = 20;
await t.test("Prepare data", async () => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:46:59");
// Since 2023-08-12 will be out of 365 range, it starts from 2023-08-13 actually
let actualStartDate = dayjs.utc("2023-08-13 00:00:00").unix();
// Simulate 1s interval for a year
for (let i = 0; i < 365 * 24 * 60 * 60; i += interval) {
UptimeCalculator.currentDate = UptimeCalculator.currentDate.add(interval, "second");
//Randomly UP, DOWN, MAINTENANCE, PENDING
let rand = Math.random();
if (rand < 0.25) {
c.update(UP);
if (UptimeCalculator.currentDate.unix() > actualStartDate) {
up++;
}
} else if (rand < 0.5) {
c.update(DOWN);
if (UptimeCalculator.currentDate.unix() > actualStartDate) {
down++;
}
} else if (rand < 0.75) {
c.update(MAINTENANCE);
if (UptimeCalculator.currentDate.unix() > actualStartDate) {
//up++;
}
} else {
c.update(PENDING);
if (UptimeCalculator.currentDate.unix() > actualStartDate) {
down++;
}
}
}
console.log("Final Date: ", UptimeCalculator.currentDate.format("YYYY-MM-DD HH:mm:ss"));
console.log("Memory usage before preparation", memoryUsage());
assert.strictEqual(c.minutelyUptimeDataList.length(), 1440);
assert.strictEqual(c.dailyUptimeDataList.length(), 365);
});
await t.test("get1YearUptime()", async () => {
assert.strictEqual(c.get1Year().uptime, up / (up + down));
});
});
});
});
/**
@@ -362,64 +421,3 @@ function memoryUsage() {
external: `${formatMemoryUsage(memoryData.external)} -> V8 external memory`,
};
}
test("Worst case", async (t) => {
// Disable on GitHub Actions, as it is not stable on it
if (process.env.GITHUB_ACTIONS) {
return;
}
console.log("Memory usage before preparation", memoryUsage());
let c = new UptimeCalculator();
let up = 0;
let down = 0;
let interval = 20;
await t.test("Prepare data", async () => {
UptimeCalculator.currentDate = dayjs.utc("2023-08-12 20:46:59");
// Since 2023-08-12 will be out of 365 range, it starts from 2023-08-13 actually
let actualStartDate = dayjs.utc("2023-08-13 00:00:00").unix();
// Simulate 1s interval for a year
for (let i = 0; i < 365 * 24 * 60 * 60; i += interval) {
UptimeCalculator.currentDate = UptimeCalculator.currentDate.add(interval, "second");
//Randomly UP, DOWN, MAINTENANCE, PENDING
let rand = Math.random();
if (rand < 0.25) {
c.update(UP);
if (UptimeCalculator.currentDate.unix() > actualStartDate) {
up++;
}
} else if (rand < 0.5) {
c.update(DOWN);
if (UptimeCalculator.currentDate.unix() > actualStartDate) {
down++;
}
} else if (rand < 0.75) {
c.update(MAINTENANCE);
if (UptimeCalculator.currentDate.unix() > actualStartDate) {
//up++;
}
} else {
c.update(PENDING);
if (UptimeCalculator.currentDate.unix() > actualStartDate) {
down++;
}
}
}
console.log("Final Date: ", UptimeCalculator.currentDate.format("YYYY-MM-DD HH:mm:ss"));
console.log("Memory usage before preparation", memoryUsage());
assert.strictEqual(c.minutelyUptimeDataList.length(), 1440);
assert.strictEqual(c.dailyUptimeDataList.length(), 365);
});
await t.test("get1YearUptime()", async () => {
assert.strictEqual(c.get1Year().uptime, up / (up + down));
});
});

52
test/backend-test/test-util.js
View File

@@ -1,18 +1,46 @@
const test = require("node:test");
const { describe, test } = require("node:test");
const assert = require("node:assert");
const dayjs = require("dayjs");
const { getDaysRemaining, getDaysBetween } = require("../../server/util-server");
const { SQL_DATETIME_FORMAT } = require("../../src/util");
test("Test getDaysBetween", async (t) => {
let days = getDaysBetween(new Date(2025, 9, 7), new Date(2025, 9, 10));
assert.strictEqual(days, 3);
days = getDaysBetween(new Date(2024, 9, 7), new Date(2025, 9, 10));
assert.strictEqual(days, 368);
});
dayjs.extend(require("dayjs/plugin/utc"));
dayjs.extend(require("dayjs/plugin/customParseFormat"));
test("Test getDaysRemaining", async (t) => {
let days = getDaysRemaining(new Date(2025, 9, 7), new Date(2025, 9, 10));
assert.strictEqual(days, 3);
days = getDaysRemaining(new Date(2025, 9, 10), new Date(2025, 9, 7));
assert.strictEqual(days, -3);
describe("Server Utilities", () => {
test("getDaysBetween() calculates days between dates within same month", () => {
const days = getDaysBetween(new Date(2025, 9, 7), new Date(2025, 9, 10));
assert.strictEqual(days, 3);
});
test("getDaysBetween() calculates days between dates across years", () => {
const days = getDaysBetween(new Date(2024, 9, 7), new Date(2025, 9, 10));
assert.strictEqual(days, 368);
});
test("getDaysRemaining() returns positive value when target date is in future", () => {
const days = getDaysRemaining(new Date(2025, 9, 7), new Date(2025, 9, 10));
assert.strictEqual(days, 3);
});
test("getDaysRemaining() returns negative value when target date is in past", () => {
const days = getDaysRemaining(new Date(2025, 9, 10), new Date(2025, 9, 7));
assert.strictEqual(days, -3);
});
test("SQL_DATETIME_FORMAT constant matches MariaDB/MySQL format", () => {
assert.strictEqual(SQL_DATETIME_FORMAT, "YYYY-MM-DD HH:mm:ss");
});
test("SQL_DATETIME_FORMAT produces valid SQL datetime string", () => {
const current = dayjs.utc("2025-12-19T01:04:02.129Z");
const sqlFormat = current.utc().format(SQL_DATETIME_FORMAT);
assert.strictEqual(sqlFormat, "2025-12-19 01:04:02");
// Verify it can be parsed back
const parsedDate = dayjs.utc(sqlFormat, SQL_DATETIME_FORMAT);
assert.strictEqual(parsedDate.unix(), current.unix());
});
});

175
test/backend-test/test-websocket.js
View File

@@ -1,175 +0,0 @@
const { WebSocketServer } = require("ws");
const { describe, test } = require("node:test");
const assert = require("node:assert");
const { WebSocketMonitorType } = require("../../server/monitor-types/websocket-upgrade");
const { UP, PENDING } = require("../../src/util");
describe("Websocket Test", {
}, () => {
test("Non Websocket Server", {}, async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://example.org",
wsIgnoreSecWebsocketAcceptHeader: false,
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
websocketMonitor.check(monitor, heartbeat, {}),
new Error("Unexpected server response: 200")
);
});
test("Secure Websocket", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://echo.websocket.org",
wsIgnoreSecWebsocketAcceptHeader: false,
};
const heartbeat = {
msg: "",
status: PENDING,
};
const expected = {
msg: "101 - OK",
status: UP,
};
await websocketMonitor.check(monitor, heartbeat, {});
assert.deepStrictEqual(heartbeat, expected);
});
test("Insecure Websocket", async (t) => {
t.after(() => wss.close());
const websocketMonitor = new WebSocketMonitorType();
const wss = new WebSocketServer({ port: 8080 });
const monitor = {
url: "ws://localhost:8080",
wsIgnoreSecWebsocketAcceptHeader: false,
};
const heartbeat = {
msg: "",
status: PENDING,
};
const expected = {
msg: "101 - OK",
status: UP,
};
await websocketMonitor.check(monitor, heartbeat, {});
assert.deepStrictEqual(heartbeat, expected);
});
test("Non compliant WS server without IgnoreSecWebsocket", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://c.img-cdn.net/yE4s7KehTFyj/",
wsIgnoreSecWebsocketAcceptHeader: false,
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
websocketMonitor.check(monitor, heartbeat, {}),
new Error("Invalid Sec-WebSocket-Accept header")
);
});
test("Non compliant WS server with IgnoreSecWebsocket", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://c.img-cdn.net/yE4s7KehTFyj/",
wsIgnoreSecWebsocketAcceptHeader: true,
};
const heartbeat = {
msg: "",
status: PENDING,
};
const expected = {
msg: "101 - OK",
status: UP,
};
await websocketMonitor.check(monitor, heartbeat, {});
assert.deepStrictEqual(heartbeat, expected);
});
test("Compliant WS server with IgnoreSecWebsocket", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://echo.websocket.org",
wsIgnoreSecWebsocketAcceptHeader: true,
};
const heartbeat = {
msg: "",
status: PENDING,
};
const expected = {
msg: "101 - OK",
status: UP,
};
await websocketMonitor.check(monitor, heartbeat, {});
assert.deepStrictEqual(heartbeat, expected);
});
test("Non WS server with IgnoreSecWebsocket", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://example.org",
wsIgnoreSecWebsocketAcceptHeader: true,
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
websocketMonitor.check(monitor, heartbeat, {}),
new Error("Unexpected server response: 200")
);
});
test("Secure Websocket with Subprotocol", async () => {
const websocketMonitor = new WebSocketMonitorType();
const monitor = {
url: "wss://echo.websocket.org",
wsIgnoreSecWebsocketAcceptHeader: false,
wsSubprotocol: "ocpp1.6",
};
const heartbeat = {
msg: "",
status: PENDING,
};
await assert.rejects(
websocketMonitor.check(monitor, heartbeat, {}),
new Error("Server sent no subprotocol")
);
});
});