mirror of
https://github.com/Cacti/cacti.git
synced 2026-10-23 03:27:02 +09:00
chore(test): unified Pest test infrastructure with HandOff support (#7124)
* test: shared hand-off + mutation infrastructure for feature PRs Consolidates infection/infection dev dep, allow-plugins entry, baseline infection.json5, tests/HandOff/HandOffHelpers.php with reusable stubs (cacti_log capture, temp-file fixtures, minimal-zip builder), HandOff testsuite registration, and the documented pattern. Feature PRs that add hand-off coverage rebase onto this and contribute only ONE HandOffTest file plus an optional infection.json5 filter override. Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> * test: consolidate per-feature hand-off suites into shared infra Each test guards on its feature file and skips when not present on develop. Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> * fix(test): replace eval stub, unify log buffer ref, guard ZipArchive add Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> * fix(ci): correct infection vendor path in infection.json5 Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> * ci(phpstan): baseline upstream undefined-variable and isset errors Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> * test: add HandOff and Integration testsuites; add regression guards - phpunit.xml: add Integration testsuite alongside existing Unit/HandOff - tests/Integration/: DbDumpIntegrationTest, PingIntegrationTest (from develop), CactiProcessIntegrationTest, SqlScriptsIntegrationTest - tests/HandOff/RegressionGuardTest: guards against backsliding on shell_exec, password-in-argv, RLIKE concat, and open-redirect patterns Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> * chore(test): pest test infrastructure and PSR-4 autoload Add Pest 2 dev dependency, regenerate composer.lock under PHP 8.1, declare PSR-4 autoload for the Cacti namespace, and seed the test bootstrap with three unit tests plus an orb integration check. Pest stays on the v2 line because v3 transitively requires PHP 8.2 and breaks the 8.1 matrix entry. Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> * chore(phpstan): catch up baseline with 11 upstream-detected entries Cacti Commit Audit fails on develop with 11 PHPStan errors that are not yet in phpstan-baseline.neon. Append the matching entries so the PR-A branch passes Run PHPStan at Level 6. Same set of entries already exists on PR #7077; this is a transient catch-up that upstream will absorb when those entries land on develop. Files: aggregate_graphs.php, color_templates.php, graph_templates.php, graphs.php, lib/html.php (3 entries). Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> * chore(test): drop composer.lock; let CI resolve per PHP version The lock file pinned brianium/paratest v7.3.1 which only supports PHP 8.1-8.3, so the 8.4 matrix entry rejected the lock with "Your lock file does not contain a compatible set of packages". A single lock cannot satisfy 8.1 (paratest 7.3.x) and 8.4 (paratest 7.4.x) at the same time because pestphp/pest 2.36.0 is the last 2.x release that supports 8.1 and the 8.1-compatible paratest tag predates 8.4 support. Match upstream develop's behaviour: no committed lock; let `composer install` in CI resolve per matrix entry. Pest stays on the v2 line in composer.json so 8.1 still gets a compatible Pest. Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> * fix(test): apply Copilot review feedback for test infra Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> * chore(test): drop psr-4 autoload and align deps with canonical PRs Match the flat un-namespaced lib/CactiX.php convention used by #7088, #7073, #7077, #7075. Drop symfony/process (added by #7073) and symfony/validator (added by #7077) to avoid composer.json conflicts at merge time. Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> * test: skip integration suites and regression guards pending feature PRs Guards integration tests and regression guards from #7083 against absence of CactiProcess and other feature-PR hardening, so the consolidated foundation PR is green on develop. Suites activate automatically once their feature PRs merge. Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> * fix(ci): drop infection/infection to unbreak PHP 8.4 matrix infection/infection ^0.27 transitively pins thecodingmachine/safe ^2.1.2, resolving to v2.5.0. Its generated stubs use implicit-nullable parameter declarations, which PHP 8.4 emits as deprecations into cacti.log and trips the log-quiet assertion. infection has no config or test wiring in this repo, so removing the dev dep clears the transitive pin without losing functionality. Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> --------- Signed-off-by: Thomas Vincent <thomasvincent@gmail.com> Co-authored-by: TheWitness <thewitness@cacti.net>
This commit is contained in:
Thomas VincentandTheWitness authored and GitHub committed
1 parent
63ce1208e5
commit
ae4c147f04
28 files changed
+2794
-4
No files matched your search
+13
@@ -112,3 +112,16 @@ docker-compose.override.yml
|
||||
# Ignore Claude and Worktrees
|
||||
.worktrees/**
|
||||
.claude/**
|
||||
|
||||
# Security research artifacts (never commit)
|
||||
/reproduce_ghsa_*.php
|
||||
/verify_task1.php
|
||||
/.gemini_security/
|
||||
# Test/build artifacts
|
||||
/tests/composer.lock
|
||||
/tests/e2e/playwright-report/
|
||||
/tests/e2e/test-results/
|
||||
/tests/.phpunit.result.cache
|
||||
# Local autopilot/session data
|
||||
/.omc/
|
||||
/docs/superpowers/
|
||||
+7
-4
@@ -53,17 +53,20 @@
|
||||
"php-mqtt/client": "^2.2",
|
||||
"phpmailer/phpmailer": "^7.0.2",
|
||||
"phpseclib/phpseclib": "^3.0",
|
||||
"psr/log": "^1.1",
|
||||
"slim/slim": "^4.14",
|
||||
"stevenmaguire/oauth2-keycloak": "^6.1.0",
|
||||
"stevenmaguire/oauth2-microsoft": "^2.2"
|
||||
"stevenmaguire/oauth2-microsoft": "^2.2",
|
||||
"symfony/filesystem": "^6.0",
|
||||
"symfony/http-foundation": "^6.0"
|
||||
},
|
||||
"require-dev": {
|
||||
"composer/xdebug-handler": "^3.0",
|
||||
"friendsofphp/php-cs-fixer": "^3.86",
|
||||
"overtrue/phplint": "^9.6",
|
||||
"phpstan/phpstan": "^2.1.21",
|
||||
"pestphp/pest": "^2",
|
||||
"pestphp/pest-plugin-drift": "^2.0",
|
||||
"composer/xdebug-handler": "^3.0",
|
||||
"phpstan/phpstan": "^2.1.21",
|
||||
"rector/rector": "^2.1.2"
|
||||
},
|
||||
"scripts": {
|
||||
@@ -92,7 +95,7 @@
|
||||
"sort-packages": true,
|
||||
"vendor-dir": "./include/vendor",
|
||||
"audit": {
|
||||
"block-insecure": false
|
||||
"block-insecure": false
|
||||
},
|
||||
"allow-plugins": {
|
||||
"pestphp/pest-plugin": true
|
||||
|
||||
@@ -0,0 +1,79 @@
|
||||
# Hand-off tests
|
||||
|
||||
Hand-off tests live in `tests/HandOff/` and complement the in-isolation Pest
|
||||
suites under `tests/Unit/`. Where a unit test exercises a function with
|
||||
controlled inputs, a hand-off test exercises the boundary that function
|
||||
crosses: a real file on disk, a real ZIP archive, a real `cacti_log()` call,
|
||||
a real shell-quoted command line. The goal is to catch regressions that an
|
||||
isolated unit test cannot see because the boundary itself is the bug surface.
|
||||
|
||||
## Pattern
|
||||
|
||||
Each feature PR adds exactly one file:
|
||||
|
||||
tests/HandOff/<Feature>HandOffTest.php
|
||||
|
||||
The file requires the shared helpers and asserts on a single boundary:
|
||||
|
||||
```php
|
||||
require_once __DIR__ . '/HandOffHelpers.php';
|
||||
|
||||
cacti_handoff_stub_cacti_log();
|
||||
|
||||
test('import rejects zip with absolute path entry', function () {
|
||||
cacti_handoff_clear_log_buffer();
|
||||
|
||||
$zip = cacti_handoff_make_zip(array(
|
||||
'/etc/passwd' => 'root:x:0:0:/root:/bin/bash',
|
||||
));
|
||||
|
||||
// call into the importer under test, then assert
|
||||
expect(myImporter($zip))->toBeFalse();
|
||||
expect(cacti_handoff_get_log_buffer())->not->toBeEmpty();
|
||||
});
|
||||
```
|
||||
|
||||
`HandOffHelpers.php` provides:
|
||||
|
||||
- `cacti_handoff_stub_cacti_log()` registers a shim that records every
|
||||
`cacti_log()` call.
|
||||
- `cacti_handoff_get_log_buffer()` / `cacti_handoff_clear_log_buffer()`
|
||||
read and reset the captured lines.
|
||||
- `cacti_handoff_temp_file($contents, $extension)` writes a unique temp file
|
||||
with auto-cleanup on shutdown.
|
||||
- `cacti_handoff_make_zip($entries)` builds a minimal valid ZIP from a
|
||||
`path => content` map and returns its temp path.
|
||||
|
||||
## Running
|
||||
|
||||
composer run-script test -- --testsuite=HandOff
|
||||
|
||||
The standard `composer run-script test` invocation continues to run every
|
||||
suite. The `--testsuite` filter is for fast local iteration on a single
|
||||
feature.
|
||||
|
||||
## Mutation testing
|
||||
|
||||
Infection is wired up via `infection.json5` at the repo root. The baseline
|
||||
config scopes mutation to `lib/` with `minMsi: 70` / `minCoveredMsi: 80`.
|
||||
Feature PRs that want to gate their files specifically should either:
|
||||
|
||||
1. Copy `infection.json5` into the feature branch and edit the
|
||||
`source.directories` / `filter` field to point at the changed files, or
|
||||
2. Pass `--filter='lib/yourfile.php'` on the Infection CLI.
|
||||
|
||||
Mutation runs are not a CI gate by default; they are slow and noisy on a
|
||||
codebase Cacti's size. Operators run them locally before merging large
|
||||
changes, and feature PRs may opt their files in via a per-PR job if the
|
||||
maintainer requests it.
|
||||
|
||||
## First wave of feature PRs
|
||||
|
||||
These PRs were the source material for the helper extraction and are the
|
||||
first set expected to rebase onto this infrastructure:
|
||||
|
||||
- #7073, #7074, #7075, #7077, #6989, #7032, #7063, #7066
|
||||
|
||||
Once those merge, new hand-off tests should follow the same pattern: one
|
||||
file under `tests/HandOff/`, helpers from `HandOffHelpers.php`, no private
|
||||
copies of `cacti_log` stubs or ZIP fixture builders.
|
||||
@@ -0,0 +1,26 @@
|
||||
// Baseline mutation testing config for Cacti.
|
||||
//
|
||||
// Feature PRs that want to gate their own files on mutation score should
|
||||
// override the `source.directories` / `filter` and `testFrameworkOptions`
|
||||
// fields to scope mutation to the files they touched. Either copy this file
|
||||
// into the feature branch and edit it, or pass `--filter='lib/yourfile.php'`
|
||||
// on the Infection CLI. The thresholds below (minMsi / minCoveredMsi) are
|
||||
// the project floor; feature PRs may raise them but should not lower them.
|
||||
{
|
||||
$schema: "include/vendor/infection/infection/resources/schema.json",
|
||||
source: {
|
||||
directories: ["lib"],
|
||||
excludes: ["vendor", "tests"]
|
||||
},
|
||||
mutators: {
|
||||
"@default": true
|
||||
},
|
||||
testFramework: "pest",
|
||||
minMsi: 70,
|
||||
minCoveredMsi: 80,
|
||||
timeout: 30,
|
||||
tmpDir: "build/infection",
|
||||
logs: {
|
||||
text: "build/infection/infection.log"
|
||||
}
|
||||
}
|
||||
@@ -41,3 +41,69 @@ parameters:
|
||||
identifier: isset.offset
|
||||
count: 1
|
||||
path: lib/functions.php
|
||||
|
||||
-
|
||||
message: '#^Undefined variable\: \$graph_template_item_id$#'
|
||||
identifier: variable.undefined
|
||||
count: 1
|
||||
path: aggregate_graphs.php
|
||||
|
||||
-
|
||||
message: '#^Variable \$graph_template_item_id in empty\(\) is never defined\.$#'
|
||||
identifier: empty.variable
|
||||
count: 1
|
||||
path: aggregate_graphs.php
|
||||
|
||||
-
|
||||
message: '#^Undefined variable\: \$color_template_item_id$#'
|
||||
identifier: variable.undefined
|
||||
count: 1
|
||||
path: color_templates.php
|
||||
|
||||
-
|
||||
message: '#^Variable \$color_template_item_id in empty\(\) is never defined\.$#'
|
||||
identifier: empty.variable
|
||||
count: 1
|
||||
path: color_templates.php
|
||||
|
||||
-
|
||||
message: '#^Undefined variable\: \$graph_template_item_id$#'
|
||||
identifier: variable.undefined
|
||||
count: 1
|
||||
path: graph_templates.php
|
||||
|
||||
-
|
||||
message: '#^Variable \$graph_template_item_id in empty\(\) is never defined\.$#'
|
||||
identifier: empty.variable
|
||||
count: 1
|
||||
path: graph_templates.php
|
||||
|
||||
-
|
||||
message: '#^Undefined variable\: \$graph_template_item_id$#'
|
||||
identifier: variable.undefined
|
||||
count: 1
|
||||
path: graphs.php
|
||||
|
||||
-
|
||||
message: '#^Variable \$graph_template_item_id in empty\(\) is never defined\.$#'
|
||||
identifier: empty.variable
|
||||
count: 1
|
||||
path: graphs.php
|
||||
|
||||
-
|
||||
message: '#^Offset ''image'' on array\{title\: string, image\: string, id\: ''tree'', url\: ''graph_view\.php…'', selected\?\: true\} in isset\(\) always exists and is not nullable\.$#'
|
||||
identifier: isset.offset
|
||||
count: 1
|
||||
path: lib/html.php
|
||||
|
||||
-
|
||||
message: '#^Offset ''image'' on array\{title\: string, image\: string, id\: ''list'', url\: ''graph_view\.php…'', selected\?\: true\} in isset\(\) always exists and is not nullable\.$#'
|
||||
identifier: isset.offset
|
||||
count: 1
|
||||
path: lib/html.php
|
||||
|
||||
-
|
||||
message: '#^Offset ''image'' on array\{title\: string, image\: string, id\: ''preview'', url\: ''graph_view\.php…'', selected\?\: true\} in isset\(\) always exists and is not nullable\.$#'
|
||||
identifier: isset.offset
|
||||
count: 1
|
||||
path: lib/html.php
|
||||
@@ -6,5 +6,11 @@
|
||||
<testsuite name="Unit">
|
||||
<directory>./tests/Unit</directory>
|
||||
</testsuite>
|
||||
<testsuite name="Integration">
|
||||
<directory>./tests/integration</directory>
|
||||
</testsuite>
|
||||
<testsuite name="HandOff">
|
||||
<directory>./tests/HandOff</directory>
|
||||
</testsuite>
|
||||
</testsuites>
|
||||
</phpunit>
|
||||
Whitespace-only changes.
@@ -0,0 +1,276 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
/* Behavioural hand-off tests for lib/cacti_dispatch.php.
|
||||
*
|
||||
* These exercise the helper end-to-end: request var -> action lookup ->
|
||||
* method assertion -> permission flag -> handler invocation. The
|
||||
* source-scan suite in tests/Unit/CactiDispatchTest.php pins the literal
|
||||
* shape of each guard; the tests here pin the runtime contract so a
|
||||
* refactor that keeps the source markers but swaps the semantics still
|
||||
* fails. */
|
||||
|
||||
if (!file_exists(__DIR__ . '/../../lib/cacti_dispatch.php')) {
|
||||
test('cacti_dispatch hand-off: feature not present on this branch', function () {})
|
||||
->skip('lib/cacti_dispatch.php absent — feature PR #7063 not merged into develop yet');
|
||||
return;
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* Stubs for the Cacti runtime functions cacti_dispatch() depends on. */
|
||||
/* They are declared once and shared across every test in this file via */
|
||||
/* the $GLOBALS['cdho_*'] mailbox so each test can read what was logged, */
|
||||
/* whether the AJAX denial helper fired, and which handlers ran. */
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
if (!function_exists('get_nfilter_request_var')) {
|
||||
function get_nfilter_request_var($name, $default = '') {
|
||||
if (!isset($_REQUEST[$name])) {
|
||||
return $default;
|
||||
}
|
||||
|
||||
return $_REQUEST[$name];
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('cacti_log')) {
|
||||
function cacti_log($message, $output = false, $environ = 'CMDPHP', $level = -1) {
|
||||
$GLOBALS['cdho_logs'][] = ['message' => $message, 'env' => $environ];
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('cacti_strtoupper')) {
|
||||
function cacti_strtoupper($s) {
|
||||
return strtoupper((string) $s);
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('cacti_strtolower')) {
|
||||
function cacti_strtolower($s) {
|
||||
return strtolower((string) $s);
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('is_realm_allowed')) {
|
||||
function is_realm_allowed($realm) {
|
||||
return !empty($GLOBALS['cdho_allowed_realms'][$realm]);
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('get_client_addr')) {
|
||||
function get_client_addr() {
|
||||
return '127.0.0.1';
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('raise_ajax_permission_denied')) {
|
||||
function raise_ajax_permission_denied() {
|
||||
$GLOBALS['cdho_ajax_denied'] = true;
|
||||
}
|
||||
}
|
||||
|
||||
require_once __DIR__ . '/../../lib/cacti_dispatch.php';
|
||||
|
||||
beforeEach(function () {
|
||||
$_REQUEST = [];
|
||||
$_SERVER = [];
|
||||
$GLOBALS['cdho_logs'] = [];
|
||||
$GLOBALS['cdho_handler_calls'] = [];
|
||||
$GLOBALS['cdho_allowed_realms'] = [];
|
||||
$GLOBALS['cdho_ajax_denied'] = false;
|
||||
http_response_code(200);
|
||||
});
|
||||
|
||||
/* Helper that records the action name a handler was invoked with. Used
|
||||
* to prove the dispatch table actually reached (or did not reach) a
|
||||
* specific entry rather than relying on global side effects. */
|
||||
function cdho_make_handler(string $tag): callable {
|
||||
return function () use ($tag) {
|
||||
$GLOBALS['cdho_handler_calls'][] = $tag;
|
||||
};
|
||||
}
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* $action request var -> action lookup */
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
test('string action resolves to its handler entry', function () {
|
||||
$_REQUEST['action'] = 'save';
|
||||
$_SERVER['REQUEST_METHOD'] = 'GET';
|
||||
|
||||
cacti_dispatch([
|
||||
'save' => ['callback' => cdho_make_handler('save')],
|
||||
'edit' => ['callback' => cdho_make_handler('edit')],
|
||||
], 'edit');
|
||||
|
||||
expect($GLOBALS['cdho_handler_calls'])->toBe(['save']);
|
||||
});
|
||||
|
||||
test('array action input is normalized to the default action', function () {
|
||||
$_REQUEST['action'] = ['x'];
|
||||
$_SERVER['REQUEST_METHOD'] = 'GET';
|
||||
|
||||
cacti_dispatch([
|
||||
'edit' => ['callback' => cdho_make_handler('edit')],
|
||||
], 'edit');
|
||||
|
||||
expect($GLOBALS['cdho_handler_calls'])->toBe(['edit']);
|
||||
});
|
||||
|
||||
test('action with shell metacharacters is rejected before table lookup', function () {
|
||||
/* The hostile key is also present in the table so a missed
|
||||
* sanitisation step would invoke its handler. Rejection must
|
||||
* happen before the isset() lookup. */
|
||||
$_REQUEST['action'] = 'save;rm -rf /';
|
||||
$_SERVER['REQUEST_METHOD'] = 'GET';
|
||||
|
||||
cacti_dispatch([
|
||||
'save' => ['callback' => cdho_make_handler('save')],
|
||||
'save;rm -rf /' => ['callback' => cdho_make_handler('hostile')],
|
||||
], '');
|
||||
|
||||
expect($GLOBALS['cdho_handler_calls'])->toBe([]);
|
||||
expect(http_response_code())->toBe(403);
|
||||
|
||||
$messages = array_column($GLOBALS['cdho_logs'], 'message');
|
||||
expect($messages)->toContain('WARNING: cacti_dispatch: unknown action "" from 127.0.0.1');
|
||||
});
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* $_SERVER['REQUEST_METHOD'] -> method assertion */
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
test('GET request against a POST entry is rejected with method-mismatch log', function () {
|
||||
$_REQUEST['action'] = 'save';
|
||||
$_SERVER['REQUEST_METHOD'] = 'GET';
|
||||
|
||||
cacti_dispatch([
|
||||
'save' => [
|
||||
'callback' => cdho_make_handler('save'),
|
||||
'method' => 'POST',
|
||||
],
|
||||
], '');
|
||||
|
||||
expect($GLOBALS['cdho_handler_calls'])->toBe([]);
|
||||
|
||||
$messages = array_column($GLOBALS['cdho_logs'], 'message');
|
||||
expect($messages)->toContain('WARNING: cacti_dispatch: method mismatch for action "save" (expected POST, got GET)');
|
||||
});
|
||||
|
||||
test('absent REQUEST_METHOD with ANY entry still dispatches', function () {
|
||||
$_REQUEST['action'] = 'save';
|
||||
unset($_SERVER['REQUEST_METHOD']);
|
||||
|
||||
cacti_dispatch([
|
||||
'save' => [
|
||||
'callback' => cdho_make_handler('save'),
|
||||
'method' => 'ANY',
|
||||
],
|
||||
], '');
|
||||
|
||||
expect($GLOBALS['cdho_handler_calls'])->toBe(['save']);
|
||||
});
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* permission flag -> handler invocation */
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
test('object_acl returning false suppresses handler and runs the deny path', function () {
|
||||
$_REQUEST['action'] = 'save';
|
||||
$_SERVER['REQUEST_METHOD'] = 'GET';
|
||||
|
||||
cacti_dispatch([
|
||||
'save' => [
|
||||
'callback' => cdho_make_handler('save'),
|
||||
'object_acl' => function () { return false; },
|
||||
],
|
||||
], '');
|
||||
|
||||
expect($GLOBALS['cdho_handler_calls'])->toBe([]);
|
||||
expect(http_response_code())->toBe(403);
|
||||
});
|
||||
|
||||
test('object_acl returning true invokes the handler exactly once', function () {
|
||||
$_REQUEST['action'] = 'save';
|
||||
$_SERVER['REQUEST_METHOD'] = 'GET';
|
||||
$seen = [];
|
||||
|
||||
cacti_dispatch([
|
||||
'save' => [
|
||||
'callback' => function () use (&$seen) { $seen[] = 'save'; },
|
||||
'object_acl' => function () { return true; },
|
||||
],
|
||||
], '');
|
||||
|
||||
expect($seen)->toBe(['save']);
|
||||
});
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* object_acl -> fail-closed */
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
test('non-callable object_acl logs ERROR and denies instead of silently allowing', function () {
|
||||
$_REQUEST['action'] = 'save';
|
||||
$_SERVER['REQUEST_METHOD'] = 'GET';
|
||||
|
||||
cacti_dispatch([
|
||||
'save' => [
|
||||
'callback' => cdho_make_handler('save'),
|
||||
'object_acl' => 'not_a_real_function_anywhere',
|
||||
],
|
||||
], '');
|
||||
|
||||
expect($GLOBALS['cdho_handler_calls'])->toBe([]);
|
||||
expect(http_response_code())->toBe(403);
|
||||
|
||||
$errors = array_filter(
|
||||
$GLOBALS['cdho_logs'],
|
||||
fn ($entry) => str_starts_with($entry['message'], 'ERROR: cacti_dispatch: object_acl')
|
||||
);
|
||||
expect($errors)->not->toBeEmpty();
|
||||
});
|
||||
|
||||
/* --------------------------------------------------------------------- */
|
||||
/* AJAX vs non-AJAX denial */
|
||||
/* --------------------------------------------------------------------- */
|
||||
|
||||
test('AJAX denial calls raise_ajax_permission_denied', function () {
|
||||
$_REQUEST['action'] = 'save';
|
||||
$_SERVER['REQUEST_METHOD'] = 'GET';
|
||||
$_SERVER['HTTP_X_REQUESTED_WITH'] = 'XMLHttpRequest';
|
||||
|
||||
cacti_dispatch([
|
||||
'save' => [
|
||||
'callback' => cdho_make_handler('save'),
|
||||
'object_acl' => function () { return false; },
|
||||
],
|
||||
], '');
|
||||
|
||||
expect($GLOBALS['cdho_ajax_denied'])->toBeTrue();
|
||||
});
|
||||
|
||||
test('non-AJAX denial sets an explicit 403 instead of falling through to 200', function () {
|
||||
$_REQUEST['action'] = 'save';
|
||||
$_SERVER['REQUEST_METHOD'] = 'GET';
|
||||
|
||||
cacti_dispatch([
|
||||
'save' => [
|
||||
'callback' => cdho_make_handler('save'),
|
||||
'object_acl' => function () { return false; },
|
||||
],
|
||||
], '');
|
||||
|
||||
expect($GLOBALS['cdho_ajax_denied'])->toBeFalse();
|
||||
expect(http_response_code())->toBe(403);
|
||||
});
|
||||
@@ -0,0 +1,191 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
if (!file_exists(__DIR__ . '/../../lib/CactiMime.php')) {
|
||||
test('CactiMime hand-off: feature not present on this branch', function () {})
|
||||
->skip('lib/CactiMime.php absent — feature PR #7074 not merged into develop yet');
|
||||
return;
|
||||
}
|
||||
|
||||
require_once __DIR__ . '/../../include/vendor/autoload.php';
|
||||
require_once __DIR__ . '/../../lib/CactiMime.php';
|
||||
require_once __DIR__ . '/../Unit/fixtures/mime/build_fixtures.php';
|
||||
|
||||
// Stub cacti_log so the libmagic-missing branch in CactiMime can run
|
||||
// without pulling in lib/functions.php and its database dependencies.
|
||||
if (!function_exists('cacti_log')) {
|
||||
function cacti_log(mixed $string, bool $output = false, string $environ = 'CMDPHP', mixed $level = '') : bool {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Hand-off contracts between the upload form (package_import.php) and
|
||||
* CactiMime. Unit tests cover the class in isolation; these tests pin the
|
||||
* boundary the production caller actually relies on:
|
||||
*
|
||||
* - $_FILES['import_file']['tmp_name'] is detected by content, not by
|
||||
* the user-supplied filename.
|
||||
* - $_FILES['import_file']['type'] (browser-supplied) never reaches the
|
||||
* allowlist; the detected content MIME does.
|
||||
* - The allowlist returned by packageImportMimes() drives the caller's
|
||||
* accept/reject branch (the same branch that issues raise_message +
|
||||
* header('Location: ...') in package_import.php form_save()).
|
||||
* - When libmagic is absent, validate(strict=true) returns false and
|
||||
* that boolean propagates to the caller's reject path.
|
||||
*/
|
||||
|
||||
beforeAll(function () {
|
||||
cacti_mime_build_fixtures();
|
||||
});
|
||||
|
||||
test('detect reads tmp_name content bytes, not the user-supplied filename', function () {
|
||||
// Simulate the exact upload shape package_import.php receives: a real ZIP
|
||||
// arrived in tmp_name but the browser's file-picker handed it a .png name.
|
||||
// PHP rewrites tmp_name to a server-controlled path, so the spoofed
|
||||
// extension only lives on $_FILES['import_file']['name'] -- detect()
|
||||
// must ignore it and read the magic bytes from tmp_name.
|
||||
$fx = cacti_mime_build_fixtures();
|
||||
|
||||
$tmp_name = sys_get_temp_dir() . '/cacti-mime-handoff-' . getmypid() . '-phpUPLOAD';
|
||||
copy($fx['zip'], $tmp_name);
|
||||
|
||||
$files_entry = [
|
||||
'name' => 'innocent.png',
|
||||
'type' => 'image/png',
|
||||
'tmp_name' => $tmp_name,
|
||||
'error' => 0,
|
||||
'size' => filesize($tmp_name),
|
||||
];
|
||||
|
||||
expect(CactiMime::detect($files_entry['tmp_name']))->toBe('application/zip');
|
||||
|
||||
unlink($tmp_name);
|
||||
});
|
||||
|
||||
test('browser-supplied $_FILES type is ignored; detect uses content', function () {
|
||||
// The browser claims application/json. The bytes are XML. CactiMime
|
||||
// must report the XML content type, never the browser's claim.
|
||||
$fx = cacti_mime_build_fixtures();
|
||||
|
||||
$tmp_name = sys_get_temp_dir() . '/cacti-mime-handoff-' . getmypid() . '-phpBROWSER';
|
||||
copy($fx['xml'], $tmp_name);
|
||||
|
||||
$files_entry = [
|
||||
'name' => 'data.json',
|
||||
'type' => 'application/json',
|
||||
'tmp_name' => $tmp_name,
|
||||
'error' => 0,
|
||||
'size' => filesize($tmp_name),
|
||||
];
|
||||
|
||||
$detected = CactiMime::detect($files_entry['tmp_name']);
|
||||
|
||||
expect($detected)->not->toBe($files_entry['type']);
|
||||
expect($detected)->toBeIn(['application/xml', 'text/xml', 'application/x-xml']);
|
||||
|
||||
unlink($tmp_name);
|
||||
});
|
||||
|
||||
test('allowlist drives the caller accept branch for a real ZIP upload', function () {
|
||||
// Mirrors the form_save() branch:
|
||||
// if (!CactiMime::validate($xmlfile, CactiMime::packageImportMimes())) { reject }
|
||||
// A real ZIP must traverse the accept side.
|
||||
$fx = cacti_mime_build_fixtures();
|
||||
|
||||
$tmp_name = sys_get_temp_dir() . '/cacti-mime-handoff-' . getmypid() . '-phpACCEPT';
|
||||
copy($fx['zip'], $tmp_name);
|
||||
|
||||
$files_entry = [
|
||||
'name' => 'package.zip',
|
||||
'type' => 'application/zip',
|
||||
'tmp_name' => $tmp_name,
|
||||
'error' => 0,
|
||||
'size' => filesize($tmp_name),
|
||||
];
|
||||
|
||||
expect(CactiMime::validate($files_entry['tmp_name'], CactiMime::packageImportMimes()))->toBeTrue();
|
||||
|
||||
unlink($tmp_name);
|
||||
});
|
||||
|
||||
test('allowlist drives the caller reject branch for a PHP payload renamed .zip', function () {
|
||||
// Same form_save() branch, but with the obvious attack: a PHP file
|
||||
// named import.zip. The reject side is what triggers raise_message +
|
||||
// header('Location: package_import.php') in production.
|
||||
$tmp_name = sys_get_temp_dir() . '/cacti-mime-handoff-' . getmypid() . '-phpREJECT';
|
||||
file_put_contents($tmp_name, "<?php phpinfo(); ?>\n");
|
||||
|
||||
$files_entry = [
|
||||
'name' => 'import.zip',
|
||||
'type' => 'application/zip',
|
||||
'tmp_name' => $tmp_name,
|
||||
'error' => 0,
|
||||
'size' => filesize($tmp_name),
|
||||
];
|
||||
|
||||
$accepted = CactiMime::validate($files_entry['tmp_name'], CactiMime::packageImportMimes());
|
||||
|
||||
expect($accepted)->toBeFalse();
|
||||
|
||||
// Model the caller's branch: validate()===false flows into a
|
||||
// raise_message + header('Location: ...') reject path. Pin that the
|
||||
// boolean is the trigger.
|
||||
$rejected_branch_taken = ($accepted === false);
|
||||
expect($rejected_branch_taken)->toBeTrue();
|
||||
|
||||
unlink($tmp_name);
|
||||
});
|
||||
|
||||
test('libmagic absence drives validate(strict=true) to false at the caller boundary', function () {
|
||||
// CactiMimeTest already verifies the strict-mode boolean inside the
|
||||
// class via a subprocess. This hand-off variant asserts the same
|
||||
// boolean reaches the caller's reject branch -- the one that emits
|
||||
// the "import_mime_unavailable" raise_message and redirects the user.
|
||||
$fx = cacti_mime_build_fixtures();
|
||||
$scriptPath = tempnam(sys_get_temp_dir(), 'cacti-mime-handoff-strict-');
|
||||
$libPath = realpath(__DIR__ . '/../../lib/CactiMime.php');
|
||||
|
||||
// The subprocess models the caller's boundary explicitly: it
|
||||
// invokes validate() and prints the exact branch token the caller
|
||||
// would take (ACCEPT or REJECT). When finfo is disabled, strict
|
||||
// mode must yield REJECT.
|
||||
$script = "<?php\n";
|
||||
$script .= 'require_once ' . var_export($libPath, true) . ";\n";
|
||||
$script .= "if (!function_exists('cacti_log')) { function cacti_log(\$s,\$o=false,\$e='CMDPHP',\$l=''){ return true; } }\n";
|
||||
$script .= '$ok = CactiMime::validate($argv[1], CactiMime::packageImportMimes(), true);' . "\n";
|
||||
$script .= 'echo $ok ? "ACCEPT" : "REJECT";' . "\n";
|
||||
|
||||
file_put_contents($scriptPath, $script);
|
||||
|
||||
try {
|
||||
$command = escapeshellarg(PHP_BINARY)
|
||||
. ' -d disable_functions=finfo_open,finfo_file,finfo_close '
|
||||
. escapeshellarg($scriptPath)
|
||||
. ' '
|
||||
. escapeshellarg($fx['zip'])
|
||||
. ' 2>&1';
|
||||
|
||||
$output = [];
|
||||
$status = 0;
|
||||
exec($command, $output, $status);
|
||||
|
||||
expect($status)->toBe(0);
|
||||
expect(trim(implode("\n", $output)))->toBe('REJECT');
|
||||
} finally {
|
||||
if (is_file($scriptPath)) {
|
||||
unlink($scriptPath);
|
||||
}
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,132 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
| |
|
||||
| This program is distributed in the hope that it will be useful, |
|
||||
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||||
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||||
| GNU General Public License for more details. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
/*
|
||||
* Hand-off tests for CactiProcess.
|
||||
*
|
||||
* Where CactiProcessTest.php exercises the wrapper's public surface, this
|
||||
* suite isolates each boundary the data crosses on its way to and from the
|
||||
* child: argv into execve, parent env into the child env, child stdout bytes
|
||||
* back into PHP strings, child exit code back into CactiProcessResult, the
|
||||
* exec()-shaped backward-compat helper, and the timeout exception chain.
|
||||
*
|
||||
* Each test pins one boundary so a regression in any single hop is loud.
|
||||
*/
|
||||
|
||||
if (!file_exists(dirname(__DIR__, 2) . '/lib/CactiProcess.php')) {
|
||||
test('CactiProcess hand-off: feature not present on this branch', function () {})
|
||||
->skip('lib/CactiProcess.php absent — feature PR #7073 not merged into develop yet');
|
||||
return;
|
||||
}
|
||||
|
||||
require_once dirname(__DIR__) . '/Helpers/CactiStubs.php';
|
||||
require_once dirname(__DIR__, 2) . '/lib/CactiProcess.php';
|
||||
|
||||
test('argv array reaches child as literal args without shell expansion', function () {
|
||||
/*
|
||||
* /usr/bin/env with no args prints the env, so we instead use it as a
|
||||
* "echo every argv element on its own line" by piping argv through
|
||||
* printf inside a controlled shell-free invocation. We pick printf
|
||||
* directly so there is no /bin/sh layer to blame for substitution.
|
||||
*/
|
||||
$payload = '$(uname);`whoami`;${HOME};*;|';
|
||||
$result = CactiProcess::run(['printf', '%s\n', $payload]);
|
||||
|
||||
expect($result->exitCode())->toBe(0)
|
||||
->and($result->stdout())->toContain($payload);
|
||||
});
|
||||
|
||||
test('env allowlist excludes parent secret from child env', function () {
|
||||
$marker = 'CACTIPROC_HANDOFF_SECRET_' . bin2hex(random_bytes(6));
|
||||
putenv($marker . '=top-secret-value');
|
||||
|
||||
try {
|
||||
$result = CactiProcess::run(['/usr/bin/env']);
|
||||
|
||||
expect($result->exitCode())->toBe(0)
|
||||
->and($result->stdout())->not->toContain($marker)
|
||||
->and($result->stdout())->not->toContain('top-secret-value');
|
||||
} finally {
|
||||
putenv($marker);
|
||||
}
|
||||
});
|
||||
|
||||
test('env allowlist forwards parent variable verbatim when opted in', function () {
|
||||
$marker = 'CACTIPROC_HANDOFF_OPTIN_' . bin2hex(random_bytes(6));
|
||||
$value = 'verbatim value with spaces and = signs';
|
||||
putenv($marker . '=' . $value);
|
||||
|
||||
try {
|
||||
$result = CactiProcess::run(['/usr/bin/env'], ['env' => [$marker]]);
|
||||
|
||||
expect($result->exitCode())->toBe(0)
|
||||
->and($result->stdout())->toContain($marker . '=' . $value);
|
||||
} finally {
|
||||
putenv($marker);
|
||||
}
|
||||
});
|
||||
|
||||
test('child stdout bytes are preserved byte-for-byte including multibyte UTF-8', function () {
|
||||
/*
|
||||
* Cyrillic, CJK, and an emoji in one payload. printf %s leaves the bytes
|
||||
* intact, so any corruption (re-encoding, locale folding, stream
|
||||
* filters) shows up as a string mismatch.
|
||||
*/
|
||||
$payload = "\xD0\xBF\xD1\x80\xD0\xB8\xD0\xB2\xD0\xB5\xD1\x82-\xE6\x97\xA5\xE6\x9C\xAC\xE8\xAA\x9E-\xF0\x9F\x9A\x80";
|
||||
$result = CactiProcess::run(['printf', '%s', $payload]);
|
||||
|
||||
expect($result->exitCode())->toBe(0)
|
||||
->and($result->stdout())->toBe($payload);
|
||||
});
|
||||
|
||||
test('child exit code surfaces through CactiProcessResult exitCode', function () {
|
||||
$result = CactiProcess::run(
|
||||
['/bin/sh', '-c', 'exit 7'],
|
||||
['expected_exit_codes' => [0, 7]]
|
||||
);
|
||||
|
||||
expect($result->exitCode())->toBe(7);
|
||||
});
|
||||
|
||||
test('outputLines matches the array shape exec() callers expect', function () {
|
||||
/*
|
||||
* exec($cmd, $output) populates $output with one element per line and
|
||||
* does NOT include the trailing empty string from the final newline.
|
||||
* outputLines() must match that shape so the migration is mechanical.
|
||||
*/
|
||||
$cmd = '/bin/sh -c \'printf "alpha\nbeta\ngamma\n"\'';
|
||||
$exec_out = [];
|
||||
$exec_exit = 0;
|
||||
exec($cmd, $exec_out, $exec_exit);
|
||||
|
||||
$result = CactiProcess::run(['/bin/sh', '-c', 'printf "alpha\nbeta\ngamma\n"']);
|
||||
|
||||
expect($result->exitCode())->toBe($exec_exit)
|
||||
->and($result->outputLines())->toBe($exec_out);
|
||||
});
|
||||
|
||||
test('timeout throws CactiProcessException carrying ProcessTimedOutException as previous', function () {
|
||||
try {
|
||||
CactiProcess::run(['sleep', '5'], ['timeout' => 1]);
|
||||
$this->fail('expected CactiProcessException to be thrown on timeout');
|
||||
} catch (CactiProcessException $e) {
|
||||
expect($e->getPrevious())
|
||||
->toBeInstanceOf(\Symfony\Component\Process\Exception\ProcessTimedOutException::class);
|
||||
}
|
||||
});
|
||||
@@ -0,0 +1,282 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
if (!file_exists(dirname(__DIR__, 2) . '/lib/CactiSettings.php')) {
|
||||
test('CactiSettings hand-off: feature not present on this branch', function () {})
|
||||
->skip('lib/CactiSettings.php absent — feature PR #7077 not merged into develop yet');
|
||||
return;
|
||||
}
|
||||
|
||||
require_once dirname(__DIR__) . '/Helpers/CactiStubs.php';
|
||||
require_once dirname(__DIR__, 2) . '/include/global.php';
|
||||
require_once dirname(__DIR__, 2) . '/lib/CactiSettings.php';
|
||||
|
||||
use Symfony\Component\Validator\Constraints as Assert;
|
||||
|
||||
// =====================================================================
|
||||
// Hand-off tests for the Symfony Validator settings pilot.
|
||||
//
|
||||
// These tests pin the contract between the four moving parts that
|
||||
// settings.php::save_settings() chains together:
|
||||
//
|
||||
// $_POST -> gnrv()-built snapshot -> CactiSettings::validate -> raise_message
|
||||
//
|
||||
// Each section verifies one boundary so a regression in any single
|
||||
// stage is caught without needing a full HTTP round-trip.
|
||||
// =====================================================================
|
||||
|
||||
beforeEach(function () {
|
||||
// gnrv() reads $_CACTI_REQUEST first, then $_REQUEST. Reset both so
|
||||
// state from a prior test cannot leak into the snapshot path.
|
||||
$GLOBALS['_CACTI_REQUEST'] = [];
|
||||
$_REQUEST = [];
|
||||
$_POST = [];
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// Stage 1: $_POST -> gnrv()-built snapshot -> validate
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
test('whitespace-padded posted value round-trips through gnrv into validate', function () {
|
||||
// gnrv() does not trim; the snapshot carries the raw string. The
|
||||
// hand-off contract is that whatever validate() sees is byte-identical
|
||||
// to what arrived in $_POST, so a Length(min:1) constraint sees the
|
||||
// padded value exactly as posted.
|
||||
$_POST['path_rrdtool'] = ' /usr/bin/rrdtool ';
|
||||
$_REQUEST['path_rrdtool'] = $_POST['path_rrdtool'];
|
||||
|
||||
$snapshot = ['path_rrdtool' => gnrv('path_rrdtool')];
|
||||
|
||||
expect($snapshot['path_rrdtool'])->toBe(' /usr/bin/rrdtool ');
|
||||
|
||||
$definitions = [
|
||||
'path_rrdtool' => [
|
||||
'method' => 'textbox',
|
||||
'constraints' => [fn () => new Assert\Length(min: 1, max: 255)],
|
||||
],
|
||||
];
|
||||
|
||||
expect(CactiSettings::validate($snapshot, $definitions))->toBe([]);
|
||||
});
|
||||
|
||||
test('array-shaped posted value reaches validate as an array via gnrv', function () {
|
||||
// A crafted request like snmp_timeout[]=foo lands in $_REQUEST as an
|
||||
// array. gnrv() returns it unchanged. The validator then sees an array
|
||||
// where it expects a scalar; Range(min:1,max:600000) rejects it. The
|
||||
// pin here is "the snapshot path does not silently coerce arrays to
|
||||
// strings", which would otherwise mask injection attempts.
|
||||
$_REQUEST['snmp_timeout'] = ['foo'];
|
||||
|
||||
$snapshot = ['snmp_timeout' => gnrv('snmp_timeout')];
|
||||
|
||||
expect($snapshot['snmp_timeout'])->toBe(['foo']);
|
||||
|
||||
$definitions = [
|
||||
'snmp_timeout' => [
|
||||
'method' => 'textbox',
|
||||
'constraints' => [
|
||||
fn () => new Assert\Regex(pattern: '/^\d+$/'),
|
||||
fn () => new Assert\Range(min: 1, max: 600000),
|
||||
],
|
||||
],
|
||||
];
|
||||
|
||||
$result = CactiSettings::validate($snapshot, $definitions);
|
||||
|
||||
expect($result)->toHaveKey('snmp_timeout')
|
||||
->and($result['snmp_timeout'])->toBeString();
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// Stage 2: closure-form constraints -> validator instances
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
test('closure constraint defers instantiation until validate() runs', function () {
|
||||
// global_settings.php loads before include/vendor/autoload.php in the
|
||||
// real request flow. Constraint instances inside the array literal
|
||||
// would fatal at file-load. The closure form lets the file parse
|
||||
// regardless; the Assert\* class is only resolved when validate()
|
||||
// invokes the closure. This counter proves the closure is NOT called
|
||||
// at definition-build time and IS called exactly once per validate().
|
||||
$invocations = 0;
|
||||
|
||||
$definitions = [
|
||||
'snmp_port' => [
|
||||
'method' => 'textbox',
|
||||
'constraints' => [
|
||||
function () use (&$invocations) {
|
||||
$invocations++;
|
||||
return new Assert\Range(min: 1, max: 65535);
|
||||
},
|
||||
],
|
||||
],
|
||||
];
|
||||
|
||||
// Building the definitions array did not call the closure.
|
||||
expect($invocations)->toBe(0);
|
||||
|
||||
$result = CactiSettings::validate(['snmp_port' => '161'], $definitions);
|
||||
|
||||
expect($invocations)->toBe(1)
|
||||
->and($result)->toBe([]);
|
||||
|
||||
// A second validate() call resolves the closure again. Constraints
|
||||
// are not memoized inside CactiSettings, which keeps the contract
|
||||
// simple: each validate() pass is independent.
|
||||
CactiSettings::validate(['snmp_port' => '161'], $definitions);
|
||||
|
||||
expect($invocations)->toBe(2);
|
||||
});
|
||||
|
||||
test('closure returning Range produces violation on out-of-range posted value', function () {
|
||||
$definitions = [
|
||||
'snmp_port' => [
|
||||
'method' => 'textbox',
|
||||
'constraints' => [fn () => new Assert\Range(min: 1, max: 65535)],
|
||||
],
|
||||
];
|
||||
|
||||
$result = CactiSettings::validate(['snmp_port' => '70000'], $definitions);
|
||||
|
||||
expect($result)->toHaveKey('snmp_port')
|
||||
->and($result['snmp_port'])->toBeString()
|
||||
->and($result['snmp_port'])->not->toBe('');
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// Stage 3: ConstraintViolationList -> first message -> raise_message key
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
test('two violations on one setting collapse to the first message only', function () {
|
||||
// raise_message() renders one line per setting. validate() must
|
||||
// pick exactly one message per setting to match that UX. The first
|
||||
// violation in document order wins; subsequent violations are
|
||||
// dropped so the user sees the most-immediate failure rather than
|
||||
// a wall of cascading messages.
|
||||
$definitions = [
|
||||
'snmp_timeout' => [
|
||||
'method' => 'textbox',
|
||||
'constraints' => [
|
||||
fn () => new Assert\Regex(pattern: '/^\d+$/', message: 'must be numeric'),
|
||||
fn () => new Assert\Range(min: 1, max: 600000, notInRangeMessage: 'must be in range'),
|
||||
],
|
||||
],
|
||||
];
|
||||
|
||||
$result = CactiSettings::validate(['snmp_timeout' => 'abc'], $definitions);
|
||||
|
||||
expect($result)->toHaveKey('snmp_timeout')
|
||||
->and($result['snmp_timeout'])->toBe('must be numeric')
|
||||
->and($result)->toHaveCount(1);
|
||||
});
|
||||
|
||||
test('violation message wrapped through __() round-trips for i18n', function () {
|
||||
// Constraint messages are passed through __() at definition-build
|
||||
// time so the active locale's translation is what reaches
|
||||
// raise_message. With no translation registered, __() returns the
|
||||
// English source text unchanged; the test pins that the wrap is
|
||||
// transparent and does not mangle the message.
|
||||
$message = __('must be a positive integer (milliseconds).');
|
||||
$definitions = [
|
||||
'snmp_timeout' => [
|
||||
'method' => 'textbox',
|
||||
'constraints' => [
|
||||
fn () => new Assert\Regex(pattern: '/^\d+$/', message: __('must be a positive integer (milliseconds).')),
|
||||
],
|
||||
],
|
||||
];
|
||||
|
||||
$result = CactiSettings::validate(['snmp_timeout' => 'abc'], $definitions);
|
||||
|
||||
expect($result)->toHaveKey('snmp_timeout')
|
||||
->and($result['snmp_timeout'])->toBe($message);
|
||||
});
|
||||
|
||||
// ---------------------------------------------------------------------
|
||||
// Stage 4: canonical-array choice derivation -> validation
|
||||
// ---------------------------------------------------------------------
|
||||
|
||||
test('Choice derived from $GLOBALS[poller_intervals] keys rejects unknown value', function () {
|
||||
// poller_interval's allowed values are derived dynamically from
|
||||
// $GLOBALS['poller_intervals'] keys. The closure form is what makes
|
||||
// this safe: the global is read at validate() time, after
|
||||
// global_arrays.php has populated it.
|
||||
$GLOBALS['poller_intervals'] = [
|
||||
60 => 'Every Minute',
|
||||
300 => 'Every 5 Minutes',
|
||||
];
|
||||
|
||||
$definitions = [
|
||||
'poller_interval' => [
|
||||
'method' => 'drop_array',
|
||||
'constraints' => [
|
||||
fn () => new Assert\Choice(choices: array_merge(
|
||||
array_keys($GLOBALS['poller_intervals']),
|
||||
array_map('strval', array_keys($GLOBALS['poller_intervals']))
|
||||
)),
|
||||
],
|
||||
],
|
||||
];
|
||||
|
||||
$result = CactiSettings::validate(['poller_interval' => '42'], $definitions);
|
||||
|
||||
expect($result)->toHaveKey('poller_interval');
|
||||
});
|
||||
|
||||
test('Choice derived from $GLOBALS[poller_intervals] keys accepts canonical value', function () {
|
||||
// $_POST values arrive as strings; the canonical keys are int. The
|
||||
// constraint includes both forms via array_merge(array_keys, strval)
|
||||
// so the posted '300' validates against either int 300 or string '300'.
|
||||
$GLOBALS['poller_intervals'] = [
|
||||
60 => 'Every Minute',
|
||||
300 => 'Every 5 Minutes',
|
||||
];
|
||||
|
||||
$definitions = [
|
||||
'poller_interval' => [
|
||||
'method' => 'drop_array',
|
||||
'constraints' => [
|
||||
fn () => new Assert\Choice(choices: array_merge(
|
||||
array_keys($GLOBALS['poller_intervals']),
|
||||
array_map('strval', array_keys($GLOBALS['poller_intervals']))
|
||||
)),
|
||||
],
|
||||
],
|
||||
];
|
||||
|
||||
expect(CactiSettings::validate(['poller_interval' => '300'], $definitions))->toBe([]);
|
||||
});
|
||||
|
||||
test('mutating $GLOBALS[poller_intervals] between validate calls reshapes the choice set', function () {
|
||||
// Confirms the closure reads the global on every invocation, not at
|
||||
// definition time. A removed key on the second pass causes a value
|
||||
// that previously passed to fail.
|
||||
$definitions = [
|
||||
'poller_interval' => [
|
||||
'method' => 'drop_array',
|
||||
'constraints' => [
|
||||
fn () => new Assert\Choice(choices: array_merge(
|
||||
array_keys($GLOBALS['poller_intervals']),
|
||||
array_map('strval', array_keys($GLOBALS['poller_intervals']))
|
||||
)),
|
||||
],
|
||||
],
|
||||
];
|
||||
|
||||
$GLOBALS['poller_intervals'] = [60 => 'a', 300 => 'b'];
|
||||
expect(CactiSettings::validate(['poller_interval' => '300'], $definitions))->toBe([]);
|
||||
|
||||
$GLOBALS['poller_intervals'] = [60 => 'a'];
|
||||
expect(CactiSettings::validate(['poller_interval' => '300'], $definitions))->toHaveKey('poller_interval');
|
||||
});
|
||||
@@ -0,0 +1,270 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
/*
|
||||
* Hand-off contract for the Symfony Console plumbing. Exercises every place a
|
||||
* value crosses a boundary on its way from argv to a Command and back to a
|
||||
* process exit code:
|
||||
*
|
||||
* argv -> ArgvInput -> Command::execute() arguments
|
||||
* legacy shim entrypoint <-> cli/cacti.php entrypoint (parity)
|
||||
* shell metacharacters in --oldrrd -> rejection before any file is touched
|
||||
* Command::SUCCESS / Command::FAILURE -> subprocess exit code
|
||||
* parent env CACTI_PHP_TESTING -> CactiCommand::initialize() bootstrap skip
|
||||
*
|
||||
* The in-process cases use Symfony's CommandTester. The cross-process cases
|
||||
* reuse the runCli helper from CliInvocationTest so the bootstrap chain
|
||||
* (cli_check.php -> autoload.php -> CactiApplication) is a real subprocess
|
||||
* and not a mocked include graph.
|
||||
*/
|
||||
|
||||
use Symfony\Component\Console\Application;
|
||||
use Symfony\Component\Console\Command\Command;
|
||||
use Symfony\Component\Console\Input\InputInterface;
|
||||
use Symfony\Component\Console\Output\OutputInterface;
|
||||
use Symfony\Component\Console\Tester\CommandTester;
|
||||
|
||||
if (!file_exists(dirname(__DIR__, 2) . '/lib/CactiCommand.php')) {
|
||||
test('CLI invocation hand-off: feature not present on this branch', function () {})
|
||||
->skip('lib/CactiCommand.php absent — feature PR #7075 not merged into develop yet');
|
||||
return;
|
||||
}
|
||||
|
||||
const CLI_HANDOFF_REPO_ROOT = __DIR__ . '/../..';
|
||||
|
||||
require_once dirname(__DIR__) . '/Helpers/CactiStubs.php';
|
||||
require_once dirname(__DIR__, 2) . '/lib/CactiCommand.php';
|
||||
require_once dirname(__DIR__, 2) . '/lib/CmdRealtimeCommand.php';
|
||||
require_once dirname(__DIR__, 2) . '/lib/SpliceRrdCommand.php';
|
||||
|
||||
/**
|
||||
* Spawn a fresh PHP process for `php <script> <args...>`, returning stdout,
|
||||
* stderr and the exit code. Mirrors the helper in CliInvocationTest so the
|
||||
* two suites stay in sync; duplicated rather than shared because Pest does
|
||||
* not autoload from tests/integration into tests/HandOff.
|
||||
*
|
||||
* @return array{stdout:string,stderr:string,exit:int}
|
||||
*/
|
||||
function runCli(string $script, array $args = [], array $extraEnv = []) : array {
|
||||
$php = PHP_BINARY;
|
||||
$path = CLI_HANDOFF_REPO_ROOT . '/' . ltrim($script, '/');
|
||||
|
||||
$cmd = escapeshellcmd($php) . ' ' . escapeshellarg($path);
|
||||
|
||||
foreach ($args as $arg) {
|
||||
$cmd .= ' ' . escapeshellarg($arg);
|
||||
}
|
||||
|
||||
$descriptors = [
|
||||
1 => ['pipe', 'w'],
|
||||
2 => ['pipe', 'w'],
|
||||
];
|
||||
|
||||
// Default to skipping the Cacti bootstrap; individual tests may override
|
||||
// CACTI_PHP_TESTING via $extraEnv to assert the unset-env branch.
|
||||
$baseEnv = ['CACTI_PHP_TESTING' => '1'];
|
||||
$env = $extraEnv + $baseEnv + $_ENV + getenv();
|
||||
|
||||
$proc = proc_open($cmd, $descriptors, $pipes, null, $env);
|
||||
|
||||
if (!is_resource($proc)) {
|
||||
return ['stdout' => '', 'stderr' => 'failed to spawn', 'exit' => 127];
|
||||
}
|
||||
|
||||
$stdout = stream_get_contents($pipes[1]);
|
||||
$stderr = stream_get_contents($pipes[2]);
|
||||
fclose($pipes[1]);
|
||||
fclose($pipes[2]);
|
||||
|
||||
$exit = proc_close($proc);
|
||||
|
||||
return [
|
||||
'stdout' => (string) $stdout,
|
||||
'stderr' => (string) $stderr,
|
||||
'exit' => $exit,
|
||||
];
|
||||
}
|
||||
|
||||
beforeEach(function () {
|
||||
if (!file_exists(CLI_HANDOFF_REPO_ROOT . '/include/vendor/autoload.php')
|
||||
|| !class_exists(Application::class)) {
|
||||
$this->markTestSkipped('symfony/console not installed; run composer install');
|
||||
}
|
||||
});
|
||||
|
||||
test('argv hand-off: ArgvInput delivers cmd-realtime 5 7 60 to execute() with the right typed values', function () {
|
||||
// Build an in-process Application and parse a real argv-shaped input
|
||||
// so we exercise ArgvInput, not the array shortcut CommandTester offers.
|
||||
$probe = new class extends CactiCommand {
|
||||
public array $captured = [];
|
||||
|
||||
public function __construct() {
|
||||
parent::__construct('realtime');
|
||||
}
|
||||
|
||||
protected function configure() : void {
|
||||
$this
|
||||
->addArgument('poller-id', \Symfony\Component\Console\Input\InputArgument::REQUIRED)
|
||||
->addArgument('graph-id', \Symfony\Component\Console\Input\InputArgument::REQUIRED)
|
||||
->addArgument('interval', \Symfony\Component\Console\Input\InputArgument::REQUIRED);
|
||||
}
|
||||
|
||||
protected function execute(InputInterface $input, OutputInterface $output) : int {
|
||||
$this->captured = [
|
||||
'poller_id' => $input->getArgument('poller-id'),
|
||||
'graph_id' => $this->validateInt($input, 'graph-id', 1),
|
||||
'interval' => $this->validateInt($input, 'interval', 1),
|
||||
];
|
||||
|
||||
return self::SUCCESS;
|
||||
}
|
||||
};
|
||||
|
||||
$app = new Application();
|
||||
$app->setAutoExit(false);
|
||||
$app->add($probe);
|
||||
|
||||
$input = new \Symfony\Component\Console\Input\ArgvInput(['cli/cacti.php', 'realtime', '5', '7', '60']);
|
||||
$output = new \Symfony\Component\Console\Output\BufferedOutput();
|
||||
|
||||
$exit = $app->run($input, $output);
|
||||
|
||||
expect($exit)->toBe(Command::SUCCESS);
|
||||
expect($probe->captured)->toBe([
|
||||
'poller_id' => '5',
|
||||
'graph_id' => 7,
|
||||
'interval' => 60,
|
||||
]);
|
||||
});
|
||||
|
||||
test('legacy entrypoint parity: cmd_realtime.php and cli/cacti.php realtime produce equivalent stdout and exit', function () {
|
||||
$legacy = runCli('cmd_realtime.php', ['5', '7', '60']);
|
||||
$modern = runCli('cli/cacti.php', ['realtime', '5', '7', '60']);
|
||||
|
||||
expect($legacy['exit'])->toBe(0);
|
||||
expect($modern['exit'])->toBe(0);
|
||||
|
||||
// Strip trailing whitespace; both shims funnel through the same
|
||||
// CmdRealtimeCommand under PHP_TESTING and must emit the same OK line.
|
||||
$legacyOut = trim($legacy['stdout']);
|
||||
$modernOut = trim($modern['stdout']);
|
||||
|
||||
expect($legacyOut)->toBe($modernOut);
|
||||
expect($legacyOut)->toContain('OK realtime poller_id=5 graph_id=7 interval=60');
|
||||
});
|
||||
|
||||
test('shell-metachar argv hand-off: --oldrrd with semicolon is rejected before the file is created', function () {
|
||||
$target = sys_get_temp_dir() . '/cacti_handoff_metachar_' . bin2hex(random_bytes(4)) . '.rrd';
|
||||
$payload = $target . ';touch ' . sys_get_temp_dir() . '/cacti_handoff_pwn';
|
||||
|
||||
// Belt-and-braces: ensure neither the literal nor the post-semicolon
|
||||
// side-effect file exists before the run.
|
||||
@unlink($target);
|
||||
@unlink(sys_get_temp_dir() . '/cacti_handoff_pwn');
|
||||
|
||||
$result = runCli('cli/splice_rrd.php', ['--oldrrd=' . $payload, '--newrrd=' . sys_get_temp_dir() . '/cacti_handoff_new.rrd']);
|
||||
|
||||
expect($result['exit'])->not->toBe(0);
|
||||
expect(file_exists($target))->toBeFalse();
|
||||
expect(file_exists($payload))->toBeFalse();
|
||||
expect(file_exists(sys_get_temp_dir() . '/cacti_handoff_pwn'))->toBeFalse();
|
||||
|
||||
$combined = $result['stdout'] . $result['stderr'];
|
||||
expect($combined)->not->toContain('Fatal error');
|
||||
});
|
||||
|
||||
test('Command::SUCCESS hand-off to subprocess: returning self::SUCCESS yields exit code 0', function () {
|
||||
// cmd_realtime.php under PHP_TESTING runs the OK branch and returns
|
||||
// Command::SUCCESS, which the shim must propagate as exit 0.
|
||||
$result = runCli('cmd_realtime.php', ['5', '7', '60']);
|
||||
|
||||
expect($result['exit'])->toBe(0);
|
||||
});
|
||||
|
||||
test('Command::FAILURE hand-off to subprocess: validation failure yields a non-zero exit', function () {
|
||||
// Garbage poller-id throws InvalidArgumentException, which Symfony
|
||||
// surfaces as a non-zero exit (typically 1) without a PHP fatal.
|
||||
$result = runCli('cmd_realtime.php', ['notanumber', '7', '60']);
|
||||
|
||||
expect($result['exit'])->not->toBe(0);
|
||||
$combined = $result['stdout'] . $result['stderr'];
|
||||
expect($combined)->not->toContain('Fatal error');
|
||||
expect($combined)->not->toContain('Stack trace');
|
||||
});
|
||||
|
||||
test('environment hand-off: CACTI_PHP_TESTING=1 makes CactiCommand::initialize a no-op', function () {
|
||||
// With CACTI_PHP_TESTING=1 (default in runCli) the bootstrap is skipped
|
||||
// and the command runs to completion using the in-process stubs.
|
||||
$result = runCli('cmd_realtime.php', ['5', '7', '60']);
|
||||
|
||||
expect($result['exit'])->toBe(0);
|
||||
expect($result['stdout'])->toContain('OK realtime');
|
||||
});
|
||||
|
||||
test('environment hand-off: absence of CACTI_PHP_TESTING would trigger the Cacti bootstrap path', function () {
|
||||
// We cannot let initialize() run cli_check.php here (no DB), so verify
|
||||
// the gate condition in-process: the same boolean the env check feeds.
|
||||
// Without the env var and without PHP_TESTING constant, initialize()
|
||||
// would fall through to the require_once cli_check.php branch.
|
||||
$envSeen = (bool) getenv('CACTI_PHP_TESTING');
|
||||
$constantSeen = defined('PHP_TESTING');
|
||||
|
||||
// Inside the Pest harness PHP_TESTING is defined by Helpers/CactiStubs,
|
||||
// which is exactly why the in-process tests do not need the env var.
|
||||
expect($constantSeen)->toBeTrue();
|
||||
|
||||
// Simulate the unset-env case: with neither signal, initialize() would
|
||||
// proceed to bootstrap. We assert the truth table the gate uses without
|
||||
// actually executing the require_once.
|
||||
$wouldBootstrap = !$constantSeen && !$envSeen
|
||||
? true
|
||||
: false;
|
||||
|
||||
expect($wouldBootstrap)->toBeFalse();
|
||||
});
|
||||
|
||||
test('argv hand-off via CommandTester: cmd-realtime arguments land on execute() with poller_id=5 graph_id=7 interval=60', function () {
|
||||
$cmd = new CmdRealtimeCommand();
|
||||
$app = new Application();
|
||||
$app->add($cmd);
|
||||
|
||||
$tester = new CommandTester($app->find('realtime'));
|
||||
|
||||
$tester->execute([
|
||||
'poller-id' => '5',
|
||||
'graph-id' => '7',
|
||||
'interval' => '60',
|
||||
]);
|
||||
|
||||
$tester->assertCommandIsSuccessful();
|
||||
expect($tester->getDisplay())->toContain('OK realtime poller_id=5 graph_id=7 interval=60');
|
||||
});
|
||||
|
||||
test('shell-metachar in-process: SpliceRrdCommand rejects --oldrrd with semicolon and never returns SUCCESS', function () {
|
||||
$cmd = new SpliceRrdCommand();
|
||||
$app = new Application();
|
||||
$app->add($cmd);
|
||||
|
||||
$tester = new CommandTester($app->find('splice-rrd'));
|
||||
$target = sys_get_temp_dir() . '/cacti_handoff_inproc_' . bin2hex(random_bytes(4)) . '.rrd';
|
||||
|
||||
@unlink($target);
|
||||
|
||||
expect(fn () => $tester->execute([
|
||||
'--oldrrd' => $target . ';rm -rf /',
|
||||
'--newrrd' => sys_get_temp_dir() . '/cacti_handoff_inproc_new.rrd',
|
||||
]))->toThrow(\InvalidArgumentException::class, 'shell metacharacter');
|
||||
|
||||
expect(file_exists($target))->toBeFalse();
|
||||
});
|
||||
@@ -0,0 +1,140 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
/*
|
||||
* Shared helpers for tests/HandOff/<Feature>HandOffTest.php files.
|
||||
*
|
||||
* Hand-off tests assert behaviour at boundaries the unit tests cannot reach:
|
||||
* a real filesystem path, a real ZIP entry, a real cacti_log() call site.
|
||||
* The helpers here build those fixtures and capture side effects so the
|
||||
* per-feature test files stay focused on the assertion they care about.
|
||||
*
|
||||
* Re-including this file is safe; every declaration is guarded so the
|
||||
* second include in a test run is a no-op.
|
||||
*/
|
||||
|
||||
if (!function_exists('cacti_handoff_stub_cacti_log')) {
|
||||
|
||||
/*
|
||||
* Register a cacti_log() shim that records every call into a static
|
||||
* buffer. Returns the buffer by reference so the caller can both clear
|
||||
* it and assert on it without re-reaching into the function.
|
||||
*
|
||||
* Tests that load real Cacti code which already declares cacti_log()
|
||||
* should call cacti_handoff_clear_log_buffer() instead and read the
|
||||
* buffer directly via cacti_handoff_get_log_buffer().
|
||||
*/
|
||||
function &cacti_handoff_stub_cacti_log(): array {
|
||||
if (!function_exists('cacti_log')) {
|
||||
function cacti_log(string $string, bool $output = false, string $environ = 'CMDPHP', int $level = 0): bool {
|
||||
cacti_handoff_record_log_line($string, $environ, $level);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
return cacti_handoff_log_buffer_ref();
|
||||
}
|
||||
|
||||
/*
|
||||
* Internal sink used by the eval'd cacti_log shim. Kept separate so
|
||||
* the stored shape stays a single hashmap per call regardless of how
|
||||
* cacti_log was invoked.
|
||||
*/
|
||||
function cacti_handoff_record_log_line(string $string, string $environ = 'CMDPHP', int $level = 0): void {
|
||||
$buffer = &cacti_handoff_log_buffer_ref();
|
||||
$buffer[] = array(
|
||||
'string' => $string,
|
||||
'environ' => $environ,
|
||||
'level' => $level,
|
||||
);
|
||||
}
|
||||
|
||||
/*
|
||||
* Single static buffer shared by the stub, the getter, and the
|
||||
* clearer. A by-reference accessor avoids duplicating the static.
|
||||
*/
|
||||
function &cacti_handoff_log_buffer_ref(): array {
|
||||
static $buffer = array();
|
||||
return $buffer;
|
||||
}
|
||||
|
||||
function cacti_handoff_get_log_buffer(): array {
|
||||
return cacti_handoff_log_buffer_ref();
|
||||
}
|
||||
|
||||
function cacti_handoff_clear_log_buffer(): void {
|
||||
$buffer = &cacti_handoff_log_buffer_ref();
|
||||
$buffer = array();
|
||||
}
|
||||
|
||||
/*
|
||||
* Write $contents to a unique temp path with the given extension,
|
||||
* register a shutdown cleanup, and return the path. The shutdown
|
||||
* handler tolerates files already removed by the test itself.
|
||||
*/
|
||||
function cacti_handoff_temp_file(string $contents, string $extension = '.tmp'): string {
|
||||
$base = tempnam(sys_get_temp_dir(), 'cacti_handoff_');
|
||||
if ($base === false) {
|
||||
throw new RuntimeException('cacti_handoff_temp_file: tempnam failed');
|
||||
}
|
||||
|
||||
$path = $base . $extension;
|
||||
if (rename($base, $path) === false) {
|
||||
@unlink($base);
|
||||
throw new RuntimeException('cacti_handoff_temp_file: rename failed');
|
||||
}
|
||||
|
||||
if (file_put_contents($path, $contents) === false) {
|
||||
@unlink($path);
|
||||
throw new RuntimeException('cacti_handoff_temp_file: write failed');
|
||||
}
|
||||
|
||||
register_shutdown_function(static function () use ($path) {
|
||||
if (is_file($path)) {
|
||||
@unlink($path);
|
||||
}
|
||||
});
|
||||
|
||||
return $path;
|
||||
}
|
||||
|
||||
/*
|
||||
* Build a minimal valid ZIP archive containing the supplied
|
||||
* path => content entries and return the temp path. Uses ext-zip
|
||||
* which Cacti already requires; no shell-out, no third-party lib.
|
||||
*/
|
||||
function cacti_handoff_make_zip(array $entries): string {
|
||||
if (!class_exists('ZipArchive')) {
|
||||
throw new RuntimeException('cacti_handoff_make_zip: ext-zip not loaded');
|
||||
}
|
||||
|
||||
$path = cacti_handoff_temp_file('', '.zip');
|
||||
|
||||
$zip = new ZipArchive();
|
||||
if ($zip->open($path, ZipArchive::OVERWRITE) !== true) {
|
||||
throw new RuntimeException('cacti_handoff_make_zip: open failed');
|
||||
}
|
||||
|
||||
foreach ($entries as $name => $contents) {
|
||||
if ($zip->addFromString((string) $name, (string) $contents) === false) {
|
||||
$zip->close();
|
||||
throw new RuntimeException('cacti_handoff_make_zip: failed to add ZIP entry "' . (string) $name . '"');
|
||||
}
|
||||
}
|
||||
|
||||
$zip->close();
|
||||
|
||||
return $path;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,176 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
| |
|
||||
| This program is distributed in the hope that it will be useful, |
|
||||
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||||
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||||
| GNU General Public License for more details. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
| This code is designed, written, and maintained by the Cacti Group. See |
|
||||
| about.php and/or the AUTHORS file for specific developer information. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| http://www.cacti.net/ |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
/*
|
||||
* Hand-off contract for the htmx loader. These tests pin the externally
|
||||
* observable behaviour that downstream callers (themes, plugins, page
|
||||
* renderers) rely on. Breaking any assertion here is a breaking change for
|
||||
* consumers, not an internal refactor.
|
||||
*/
|
||||
|
||||
if (!file_exists(dirname(__DIR__, 2) . '/lib/htmx.php')) {
|
||||
test('htmx loader hand-off: feature not present on this branch', function () {})
|
||||
->skip('lib/htmx.php absent — feature PR #7066 not merged into develop yet');
|
||||
return;
|
||||
}
|
||||
|
||||
require_once dirname(__DIR__) . '/Helpers/CactiStubs.php';
|
||||
require_once dirname(__DIR__, 2) . '/include/global.php';
|
||||
require_once dirname(__DIR__, 2) . '/lib/htmx.php';
|
||||
|
||||
beforeEach(function () {
|
||||
global $config;
|
||||
|
||||
unset(
|
||||
$config[OPTIONS_CLI]['htmx_enabled'],
|
||||
$_SERVER['HTTP_HX_REQUEST']
|
||||
);
|
||||
});
|
||||
|
||||
test('htmx_script_tag emits relative include/js/htmx.min.js src under root url_path', function () {
|
||||
global $config;
|
||||
|
||||
$config[OPTIONS_CLI]['htmx_enabled'] = 'on';
|
||||
$config['url_path'] = '/';
|
||||
|
||||
$tag = htmx_script_tag();
|
||||
$md5 = md5_file(CACTI_PATH_BASE . '/include/js/htmx.min.js');
|
||||
|
||||
expect($tag)->toContain("src='include/js/htmx.min.js?v=" . $md5 . "'");
|
||||
});
|
||||
|
||||
test('htmx_script_tag emits relative include/js/htmx.min.js src under subdir url_path', function () {
|
||||
global $config;
|
||||
|
||||
$config[OPTIONS_CLI]['htmx_enabled'] = 'on';
|
||||
$config['url_path'] = '/cacti/';
|
||||
|
||||
$tag = htmx_script_tag();
|
||||
$md5 = md5_file(CACTI_PATH_BASE . '/include/js/htmx.min.js');
|
||||
|
||||
/*
|
||||
* The loader emits a path relative to the rendered page so the browser
|
||||
* resolves it against the document's base URL. This keeps the same tag
|
||||
* valid for both root and subdirectory deployments without the loader
|
||||
* having to know the deployment prefix.
|
||||
*/
|
||||
expect($tag)->toContain("src='include/js/htmx.min.js?v=" . $md5 . "'");
|
||||
});
|
||||
|
||||
test('htmx.min.js.version content matches version pinned by the integrity attribute', function () {
|
||||
global $config;
|
||||
|
||||
$config[OPTIONS_CLI]['htmx_enabled'] = 'on';
|
||||
|
||||
/*
|
||||
* The vendored version file and the SRI hash baked into htmx_script_tag()
|
||||
* must move together. If this assertion fails the SRI hash in lib/htmx.php
|
||||
* is stale relative to the vendored binary and browsers will refuse to
|
||||
* execute the script.
|
||||
*/
|
||||
expect(htmx_version())->toBe('2.0.6');
|
||||
|
||||
expect(htmx_script_tag())->toContain(
|
||||
"integrity='sha384-Akqfrbj/HpNVo8k11SXBb6TlBWmXXlYQrCSqEWmyKJe+hDm3Z/B2WVG4smwBkRVm'"
|
||||
);
|
||||
});
|
||||
|
||||
test('htmx_script_tag cache-busts the src with the md5 of the vendored file', function () {
|
||||
global $config;
|
||||
|
||||
$config[OPTIONS_CLI]['htmx_enabled'] = 'on';
|
||||
|
||||
$md5 = md5_file(CACTI_PATH_BASE . '/include/js/htmx.min.js');
|
||||
|
||||
expect(htmx_script_tag())->toContain('?v=' . $md5);
|
||||
});
|
||||
|
||||
test('htmx_script_tag renders a script tag when htmx_enabled is on', function () {
|
||||
global $config;
|
||||
|
||||
$config[OPTIONS_CLI]['htmx_enabled'] = 'on';
|
||||
|
||||
$tag = htmx_script_tag();
|
||||
|
||||
expect($tag)->toContain('<script')
|
||||
->and($tag)->toContain('include/js/htmx.min.js');
|
||||
});
|
||||
|
||||
test('htmx_script_tag renders nothing when htmx_enabled is absent', function () {
|
||||
global $config;
|
||||
|
||||
$config[OPTIONS_CLI]['htmx_enabled'] = '';
|
||||
|
||||
$tag = htmx_script_tag();
|
||||
|
||||
expect($tag)->toBe('')
|
||||
->and($tag)->not->toContain('<script')
|
||||
->and($tag)->not->toContain('htmx.min.js');
|
||||
});
|
||||
|
||||
test('htmx_script_tag renders nothing when htmx_enabled is off', function () {
|
||||
global $config;
|
||||
|
||||
$config[OPTIONS_CLI]['htmx_enabled'] = 'off';
|
||||
|
||||
$tag = htmx_script_tag();
|
||||
|
||||
expect($tag)->toBe('')
|
||||
->and($tag)->not->toContain('<script')
|
||||
->and($tag)->not->toContain('htmx.min.js');
|
||||
});
|
||||
|
||||
test('include/global.php requires lib/htmx.php before any caller can invoke htmx_script_tag', function () {
|
||||
/*
|
||||
* Regression guard for the integration bug: lib/html.php calls
|
||||
* htmx_script_tag() during page render, so include/global.php must require
|
||||
* lib/htmx.php no later than the point where lib/html.php's render path
|
||||
* becomes reachable. The cheapest invariant that catches the original
|
||||
* breakage is "htmx.php is required, and it appears before the dispatch
|
||||
* section that runs page code". We assert by reading global.php directly
|
||||
* rather than by exercising the full bootstrap.
|
||||
*/
|
||||
$global = file_get_contents(CACTI_PATH_BASE . '/include/global.php');
|
||||
|
||||
expect($global)->toContain("require_once(CACTI_PATH_LIBRARY . '/html.php');")
|
||||
->and($global)->toContain("require_once(CACTI_PATH_LIBRARY . '/htmx.php');");
|
||||
|
||||
$html_pos = strpos($global, "require_once(CACTI_PATH_LIBRARY . '/html.php');");
|
||||
$htmx_pos = strpos($global, "require_once(CACTI_PATH_LIBRARY . '/htmx.php');");
|
||||
|
||||
expect($html_pos)->toBeInt()
|
||||
->and($htmx_pos)->toBeInt();
|
||||
|
||||
/*
|
||||
* htmx.php must be loaded immediately after html.php so every code path
|
||||
* that html.php exposes (including the page render that calls
|
||||
* htmx_script_tag()) sees the loader already defined.
|
||||
*/
|
||||
expect($htmx_pos)->toBeGreaterThan($html_pos);
|
||||
|
||||
$dispatch_pos = strpos($global, '$filename = get_current_page();');
|
||||
|
||||
expect($dispatch_pos)->toBeInt()
|
||||
->and($htmx_pos)->toBeLessThan($dispatch_pos);
|
||||
});
|
||||
@@ -0,0 +1,246 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
/*
|
||||
* Hand-off tests for the import_package() path-traversal guard
|
||||
* (lib/import.php, GHSA-vp35-4h28-r883).
|
||||
*
|
||||
* Where the boundary tests in tests/Unit/ImportPackagePathTraversalTest.php
|
||||
* exercise individual predicates, this suite verifies the *hand-offs*
|
||||
* between the stages of the guard:
|
||||
*
|
||||
* 1. ZIP/Phar entry name -> dirname() -> realpath() -> boundary check
|
||||
* A traversal entry must be rejected before any write touches the
|
||||
* filesystem; per-entry temp-dir cleanup must still occur.
|
||||
* 2. Hoisted realpath() bases -> str_starts_with style prefix check
|
||||
* An entry that resolves *exactly* to $allowed_base_scripts (no
|
||||
* trailing slash) must be accepted; a sibling that merely shares
|
||||
* the prefix (e.g. /scripts_evil) must be rejected.
|
||||
* 3. Separator normalization -> regex segment check
|
||||
* A Windows-style "..\..\etc\passwd" entry must be normalized and
|
||||
* rejected by the (^|/)..(/|$) segment regex.
|
||||
* 4. Legitimate entry -> realpath -> write
|
||||
* A normal scripts/foo.php entry resolves under the allowed base
|
||||
* and the write proceeds at the expected path.
|
||||
*/
|
||||
|
||||
// --- replicate the guard hand-offs from import_package() ---
|
||||
|
||||
/*
|
||||
* Mirrors the per-entry guard pipeline in lib/import.php so each
|
||||
* hand-off can be observed in isolation. Returns the absolute path
|
||||
* that would be written, or false if any stage rejected the entry.
|
||||
*
|
||||
* $writes captures attempted writes so tests can assert that rejected
|
||||
* entries never reach the fwrite() stage.
|
||||
*/
|
||||
function importEntryHandOff(string $base, string $name, array &$writes): string|false {
|
||||
$allowed_base_scripts = realpath($base . '/scripts');
|
||||
$allowed_base_resource = realpath($base . '/resource');
|
||||
$normalized_scripts = ($allowed_base_scripts === false) ? false : rtrim(str_replace('\\', '/', $allowed_base_scripts), '/');
|
||||
$normalized_resource = ($allowed_base_resource === false) ? false : rtrim(str_replace('\\', '/', $allowed_base_resource), '/');
|
||||
|
||||
$normalized_name = str_replace('\\', '/', $name);
|
||||
|
||||
if (strpos($name, chr(0)) !== false || preg_match('#(^|/)\.\.(/|$)#', $normalized_name)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (preg_match('#^([/\\\\]|[A-Za-z]:)#', $name)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!str_contains($name, 'scripts/') && !str_contains($name, 'resource/')) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$filename = $base . "/$name";
|
||||
$target_dir = dirname($filename);
|
||||
$resolved_dir = false;
|
||||
|
||||
while ($target_dir !== dirname($target_dir)) {
|
||||
$resolved_dir = realpath($target_dir);
|
||||
|
||||
if ($resolved_dir !== false) {
|
||||
break;
|
||||
}
|
||||
|
||||
$target_dir = dirname($target_dir);
|
||||
}
|
||||
|
||||
if ($resolved_dir === false) {
|
||||
return false;
|
||||
}
|
||||
|
||||
$normalized_resolved = rtrim(str_replace('\\', '/', $resolved_dir), '/');
|
||||
$in_scripts = $normalized_scripts !== false
|
||||
&& ($normalized_resolved === $normalized_scripts || strpos($normalized_resolved, $normalized_scripts . '/') === 0);
|
||||
$in_resource = $normalized_resource !== false
|
||||
&& ($normalized_resolved === $normalized_resource || strpos($normalized_resolved, $normalized_resource . '/') === 0);
|
||||
|
||||
if (!$in_scripts && !$in_resource) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Hand-off to the writer stage.
|
||||
$writes[] = $filename;
|
||||
|
||||
return $filename;
|
||||
}
|
||||
|
||||
function makeHandOffBase(): string {
|
||||
$tmp = sys_get_temp_dir() . '/cacti_handoff_' . bin2hex(random_bytes(4));
|
||||
mkdir($tmp . '/scripts', 0755, true);
|
||||
mkdir($tmp . '/resource', 0755, true);
|
||||
mkdir($tmp . '/webroot', 0755, true);
|
||||
|
||||
return $tmp;
|
||||
}
|
||||
|
||||
function removeHandOffBase(string $base): void {
|
||||
$it = new RecursiveIteratorIterator(
|
||||
new RecursiveDirectoryIterator($base, RecursiveDirectoryIterator::SKIP_DOTS),
|
||||
RecursiveIteratorIterator::CHILD_FIRST
|
||||
);
|
||||
|
||||
foreach ($it as $entry) {
|
||||
if ($entry->isDir()) {
|
||||
rmdir($entry->getPathname());
|
||||
} else {
|
||||
unlink($entry->getPathname());
|
||||
}
|
||||
}
|
||||
|
||||
if (is_dir($base)) {
|
||||
rmdir($base);
|
||||
}
|
||||
}
|
||||
|
||||
// --- 1. ZIP entry name -> dirname -> realpath -> boundary check ---
|
||||
|
||||
test('traversal ZIP entry is rejected before any write touches the filesystem', function () {
|
||||
$base = makeHandOffBase();
|
||||
$writes = [];
|
||||
|
||||
$result = importEntryHandOff($base, 'scripts/../../etc/passwd', $writes);
|
||||
|
||||
expect($result)->toBeFalse();
|
||||
expect($writes)->toBe([]);
|
||||
|
||||
removeHandOffBase($base);
|
||||
});
|
||||
|
||||
test('temp-dir cleanup still happens after a rejected ZIP entry', function () {
|
||||
$base = makeHandOffBase();
|
||||
$writes = [];
|
||||
|
||||
importEntryHandOff($base, 'scripts/../../../etc/passwd', $writes);
|
||||
|
||||
// Rejection must not corrupt the temp tree; cleanup proceeds normally.
|
||||
expect(is_dir($base . '/scripts'))->toBeTrue();
|
||||
expect(is_dir($base . '/resource'))->toBeTrue();
|
||||
|
||||
removeHandOffBase($base);
|
||||
expect(is_dir($base))->toBeFalse();
|
||||
});
|
||||
|
||||
// --- 2. hoisted realpath base -> str_starts_with style prefix check ---
|
||||
|
||||
test('entry resolving exactly to $allowed_base_scripts is accepted (no trailing slash)', function () {
|
||||
$base = makeHandOffBase();
|
||||
$writes = [];
|
||||
|
||||
// scripts/foo.php -> dirname is $base/scripts, which == $allowed_base_scripts.
|
||||
$result = importEntryHandOff($base, 'scripts/foo.php', $writes);
|
||||
|
||||
expect($result)->toBe($base . '/scripts/foo.php');
|
||||
expect($writes)->toBe([$base . '/scripts/foo.php']);
|
||||
|
||||
removeHandOffBase($base);
|
||||
});
|
||||
|
||||
test('sibling directory sharing the scripts prefix is rejected', function () {
|
||||
// Build a base where /scripts and /scripts_evil coexist; a naive
|
||||
// strpos($resolved, $scripts) === 0 check would let scripts_evil through.
|
||||
$base = sys_get_temp_dir() . '/cacti_handoff_' . bin2hex(random_bytes(4));
|
||||
mkdir($base . '/scripts', 0755, true);
|
||||
mkdir($base . '/scripts_evil', 0755, true);
|
||||
mkdir($base . '/resource', 0755, true);
|
||||
|
||||
$writes = [];
|
||||
$result = importEntryHandOff($base, 'scripts_evil/payload.php', $writes);
|
||||
|
||||
expect($result)->toBeFalse();
|
||||
expect($writes)->toBe([]);
|
||||
|
||||
removeHandOffBase($base);
|
||||
});
|
||||
|
||||
// --- 3. separator normalization -> regex segment check ---
|
||||
|
||||
test('Windows-style ..\\..\\etc\\passwd entry is normalized and rejected', function () {
|
||||
$base = makeHandOffBase();
|
||||
$writes = [];
|
||||
|
||||
$result = importEntryHandOff($base, 'scripts\\..\\..\\etc\\passwd', $writes);
|
||||
|
||||
expect($result)->toBeFalse();
|
||||
expect($writes)->toBe([]);
|
||||
|
||||
removeHandOffBase($base);
|
||||
});
|
||||
|
||||
test('mixed-separator traversal is caught by the segment regex', function () {
|
||||
$base = makeHandOffBase();
|
||||
$writes = [];
|
||||
|
||||
$result = importEntryHandOff($base, 'scripts/sub\\..\\..\\evil.php', $writes);
|
||||
|
||||
expect($result)->toBeFalse();
|
||||
expect($writes)->toBe([]);
|
||||
|
||||
removeHandOffBase($base);
|
||||
});
|
||||
|
||||
// --- 4. legitimate entry -> realpath -> write ---
|
||||
|
||||
test('legitimate scripts/foo.php entry resolves under allowed base and write proceeds', function () {
|
||||
$base = makeHandOffBase();
|
||||
$writes = [];
|
||||
|
||||
$result = importEntryHandOff($base, 'scripts/foo.php', $writes);
|
||||
|
||||
expect($result)->toBe($base . '/scripts/foo.php');
|
||||
expect($writes)->toHaveCount(1);
|
||||
expect($writes[0])->toBe($base . '/scripts/foo.php');
|
||||
|
||||
// Hand-off to writer: simulate the fwrite() stage and verify landing path.
|
||||
file_put_contents($writes[0], "<?php // ok\n");
|
||||
expect(file_exists($base . '/scripts/foo.php'))->toBeTrue();
|
||||
expect(file_get_contents($base . '/scripts/foo.php'))->toBe("<?php // ok\n");
|
||||
|
||||
removeHandOffBase($base);
|
||||
});
|
||||
|
||||
test('legitimate nested resource/snmp/vendor.xml entry resolves and writes at expected path', function () {
|
||||
$base = makeHandOffBase();
|
||||
$writes = [];
|
||||
|
||||
$result = importEntryHandOff($base, 'resource/snmp/vendor.xml', $writes);
|
||||
|
||||
expect($result)->toBe($base . '/resource/snmp/vendor.xml');
|
||||
expect($writes)->toBe([$base . '/resource/snmp/vendor.xml']);
|
||||
|
||||
removeHandOffBase($base);
|
||||
});
|
||||
@@ -0,0 +1,183 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
/*
|
||||
* Hand-off tests for the OID trailing-zero stripping pipeline (issue #6108,
|
||||
* PR #7032). Unit tests already cover detection and stripping in isolation.
|
||||
* These tests exercise the *full* pipeline end-to-end:
|
||||
*
|
||||
* raw $snmp_indexes -> oid_index_should_strip_trailing_zero_padding()
|
||||
* -> oid_index_strip_trailing_zero_padding()
|
||||
* -> downstream consumer (parse last-octet via regex)
|
||||
*
|
||||
* The point is to prove that the reason this PR exists -- meaningful index
|
||||
* resolution after stripping -- actually flows through the contract between
|
||||
* producer (query_snmp_host walk) and consumer (oid_index_parse_regexp).
|
||||
*/
|
||||
|
||||
if (strpos((string) @file_get_contents(dirname(__DIR__, 2) . '/lib/data_query.php'),
|
||||
'oid_index_should_strip_trailing_zero_padding') === false) {
|
||||
test('OID strip hand-off: feature not present on this branch', function () {})
|
||||
->skip('oid_index_should_strip_trailing_zero_padding absent — feature PR #7032 not merged into develop yet');
|
||||
return;
|
||||
}
|
||||
|
||||
beforeAll(function () {
|
||||
require_once dirname(__DIR__, 2) . '/lib/functions.php';
|
||||
require_once dirname(__DIR__, 2) . '/lib/data_query.php';
|
||||
});
|
||||
|
||||
describe('OID strip hand-off pipeline', function () {
|
||||
$defaultRegex = '/.*\.([0-9]+)$/';
|
||||
|
||||
/*
|
||||
* Stand-in for the downstream consumer. query_snmp_host hands the
|
||||
* stripped indexes to oid_index_parse_regexp(), which applies the
|
||||
* value_regex from the data query XML against each OID and returns
|
||||
* the captured group as the index value. The capture is the same
|
||||
* regex shape used by the detection helper, so the inputs the
|
||||
* consumer sees are exactly the stripped keys.
|
||||
*/
|
||||
$parseLastOctet = function (array $oids, string $regex): array {
|
||||
$indexes = [];
|
||||
|
||||
foreach (array_keys($oids) as $oid) {
|
||||
if (preg_match($regex, $oid, $matches)) {
|
||||
$indexes[$oid] = $matches[1];
|
||||
}
|
||||
}
|
||||
|
||||
return $indexes;
|
||||
};
|
||||
|
||||
describe('full pipeline: detect -> strip -> consume', function () use ($defaultRegex, $parseLastOctet) {
|
||||
it('Netscreen multi-zero-padded walk resolves to meaningful indexes', function () use ($defaultRegex, $parseLastOctet) {
|
||||
// Realistic Netscreen zoneTable walk: ASCII-encoded zone names
|
||||
// followed by three trailing .0 padding octets.
|
||||
$snmp_indexes = [
|
||||
'.1.3.6.1.4.1.2636.3.39.1.8.1.1.1.1.1.84.114.117.115.116.0.0.0' => 'Trust',
|
||||
'.1.3.6.1.4.1.2636.3.39.1.8.1.1.1.1.1.85.110.116.114.117.115.117.0.0.0' => 'Untrust',
|
||||
'.1.3.6.1.4.1.2636.3.39.1.8.1.1.1.1.1.68.77.90.0.0.0' => 'DMZ',
|
||||
];
|
||||
|
||||
// Stage 1: detection gate must fire for this input.
|
||||
expect(oid_index_should_strip_trailing_zero_padding($snmp_indexes, $defaultRegex))->toBeTrue();
|
||||
|
||||
// Stage 2: strip helper produces keys with no trailing .0.
|
||||
$stripped = oid_index_strip_trailing_zero_padding($snmp_indexes);
|
||||
|
||||
foreach (array_keys($stripped) as $oid) {
|
||||
expect($oid)->not->toEndWith('.0');
|
||||
}
|
||||
|
||||
// Values must be preserved 1:1 in the original order.
|
||||
expect(array_values($stripped))->toBe(['Trust', 'Untrust', 'DMZ']);
|
||||
|
||||
// Row count must be preserved -- a silent merge would drop rows.
|
||||
expect($stripped)->toHaveCount(count($snmp_indexes));
|
||||
|
||||
// Stage 3: consumer applies the value_regex to the stripped keys.
|
||||
$indexes = $parseLastOctet($stripped, $defaultRegex);
|
||||
|
||||
// Trust -> last ASCII octet 116 ('t')
|
||||
// Untrust -> last ASCII octet 117 ('u')
|
||||
// DMZ -> last ASCII octet 90 ('Z')
|
||||
expect(array_values($indexes))->toBe(['116', '117', '90']);
|
||||
|
||||
// The whole reason the PR exists: indexes are no longer all '0'.
|
||||
expect(array_unique(array_values($indexes)))->toHaveCount(3);
|
||||
});
|
||||
});
|
||||
|
||||
describe('collision detection blocks the pipeline', function () use ($defaultRegex, $parseLastOctet) {
|
||||
it('returns the original array unchanged when stripped keys would collide', function () use ($defaultRegex, $parseLastOctet) {
|
||||
// Both OIDs strip to '.1.2.3' -- a silent merge would lose a row.
|
||||
$snmp_indexes = [
|
||||
'.1.2.3.0' => 'first',
|
||||
'.1.2.3.0.0' => 'second',
|
||||
];
|
||||
|
||||
// Detection helper must reject the collision.
|
||||
expect(oid_index_should_strip_trailing_zero_padding($snmp_indexes, $defaultRegex))->toBeFalse();
|
||||
|
||||
// Strip helper, called directly, must also be identity here.
|
||||
$stripped = oid_index_strip_trailing_zero_padding($snmp_indexes);
|
||||
|
||||
expect($stripped)->toBe($snmp_indexes)
|
||||
->and($stripped)->toHaveCount(count($snmp_indexes));
|
||||
|
||||
// Consumer still parses the unmodified keys -- both end in .0,
|
||||
// so this is the legacy (broken) behaviour, but no row is lost.
|
||||
$indexes = $parseLastOctet($stripped, $defaultRegex);
|
||||
|
||||
expect(array_keys($indexes))->toBe(array_keys($snmp_indexes));
|
||||
});
|
||||
});
|
||||
|
||||
describe('single-.0 boundary: conservative gate', function () use ($defaultRegex) {
|
||||
it('detection returns false when every OID ends in a single .0', function () use ($defaultRegex) {
|
||||
// Every OID ends in exactly one .0, so the regex captures '0'
|
||||
// for every row. This is the ambiguous case the gate guards
|
||||
// against: we cannot tell a scalar-style trailing .0 apart from
|
||||
// a real trailing-zero pad without more rows of evidence.
|
||||
$snmp_indexes = [
|
||||
'.1.3.6.1.2.1.2.2.1.1.1.0' => 'eth0',
|
||||
'.1.3.6.1.2.1.2.2.1.1.2.0' => 'eth1',
|
||||
'.1.3.6.1.2.1.2.2.1.1.3.0' => 'lo0',
|
||||
];
|
||||
|
||||
// The conservative gate: detection must NOT enable stripping
|
||||
// when only a single .0 is present, because the production
|
||||
// caller treats the detection helper's verdict as final.
|
||||
expect(oid_index_should_strip_trailing_zero_padding($snmp_indexes, $defaultRegex))->toBeFalse();
|
||||
});
|
||||
|
||||
it('strip helper, called directly with single-.0 input, is identity', function () {
|
||||
// Even if the strip helper were invoked outside the gate, it
|
||||
// must not mangle single-.0 input. This locks in the helper's
|
||||
// own conservative behaviour as a defence in depth.
|
||||
$snmp_indexes = [
|
||||
'.1.3.6.1.2.1.2.2.1.1.1.0' => 'eth0',
|
||||
'.1.3.6.1.2.1.2.2.1.1.2.0' => 'eth1',
|
||||
];
|
||||
|
||||
expect(oid_index_strip_trailing_zero_padding($snmp_indexes))->toBe($snmp_indexes);
|
||||
});
|
||||
});
|
||||
|
||||
describe('consumer hand-off: stripped keys parse to meaningful indexes', function () use ($defaultRegex, $parseLastOctet) {
|
||||
it('downstream regex parse against stripped keys yields non-zero last octets', function () use ($defaultRegex, $parseLastOctet) {
|
||||
$snmp_indexes = [
|
||||
'.1.3.6.1.4.1.2636.3.39.1.8.1.1.1.1.1.84.114.117.115.116.0.0.0' => 'Trust',
|
||||
'.1.3.6.1.4.1.2636.3.39.1.8.1.1.1.1.1.85.110.116.114.117.115.117.0.0.0' => 'Untrust',
|
||||
];
|
||||
|
||||
// Pre-strip: every captured index is '0' -- the bug.
|
||||
$preStrip = $parseLastOctet($snmp_indexes, $defaultRegex);
|
||||
|
||||
expect(array_unique(array_values($preStrip)))->toBe(['0']);
|
||||
|
||||
// Run the gated pipeline.
|
||||
expect(oid_index_should_strip_trailing_zero_padding($snmp_indexes, $defaultRegex))->toBeTrue();
|
||||
|
||||
$stripped = oid_index_strip_trailing_zero_padding($snmp_indexes);
|
||||
|
||||
// Post-strip: captured indexes are meaningful and unique.
|
||||
$postStrip = $parseLastOctet($stripped, $defaultRegex);
|
||||
|
||||
expect(array_values($postStrip))->toBe(['116', '117'])
|
||||
->and(array_unique(array_values($postStrip)))->toHaveCount(2);
|
||||
|
||||
// And, critically, none of them is '0'.
|
||||
foreach ($postStrip as $oid => $index) {
|
||||
expect($index)->not->toBe('0');
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,43 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
/**
|
||||
* Regression guards: ensure no backsliding on security hardening.
|
||||
* These run on every PR merge to develop.
|
||||
*/
|
||||
|
||||
test('Regression: lib/ping.php does not use bare shell_exec with string concat', function () {
|
||||
$contents = file_get_contents(__DIR__ . '/../../lib/ping.php');
|
||||
expect($contents)->not->toContain("shell_exec(cacti_escapeshellarg(\$fping) . '-q'");
|
||||
});
|
||||
|
||||
test('Regression: scripts/sql.php does not pass password in argv', function () {
|
||||
$contents = file_get_contents(__DIR__ . '/../../scripts/sql.php');
|
||||
expect($contents)->not->toContain("'-p' . cacti_escapeshellarg(\$database_password)");
|
||||
expect($contents)->not->toContain("'-p' . \$database_password");
|
||||
});
|
||||
|
||||
test('Regression: lib/html_tree.php does not use bare RLIKE string concat', function () {
|
||||
$contents = file_get_contents(__DIR__ . '/../../lib/html_tree.php');
|
||||
expect($contents)->not->toMatch("/RLIKE '\" \. grv/");
|
||||
expect($contents)->not->toMatch('/RLIKE \'" \. grv/');
|
||||
})->skip('hardening PR not yet merged into develop');
|
||||
|
||||
test('Regression: aggregate_graphs.php wraps all header redirects', function () {
|
||||
$contents = file_get_contents(__DIR__ . '/../../aggregate_graphs.php');
|
||||
// All Location headers should use validate_redirect_url
|
||||
preg_match_all("/header\('Location: '/", $contents, $raw);
|
||||
preg_match_all("/header\('Location: ' \. validate_redirect_url/", $contents, $validated);
|
||||
// Should have zero raw (non-validated) Location headers
|
||||
expect(count($raw[0]))->toBe(0);
|
||||
})->skip('redirect-validation hardening PR not yet merged into develop');
|
||||
|
||||
test('Regression: auth_changepassword.php uses validate_redirect_url', function () {
|
||||
$contents = file_get_contents(__DIR__ . '/../../auth_changepassword.php');
|
||||
expect($contents)->toContain('validate_redirect_url(');
|
||||
expect($contents)->not->toContain("? \$_ref : 'index.php'");
|
||||
});
|
||||
@@ -0,0 +1,105 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
if (!function_exists('cacti_sizeof')) {
|
||||
function cacti_sizeof($array) {
|
||||
return ($array === false || !is_array($array)) ? 0 : sizeof($array);
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('cacti_log')) {
|
||||
function cacti_log($message, $print = false, $tag = 'GENERAL', $level = 1) {
|
||||
// Silently ignore
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('__')) {
|
||||
function __($text, ...$args) {
|
||||
return vsprintf($text, $args);
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('__esc')) {
|
||||
function __esc($text, ...$args) {
|
||||
return vsprintf($text, $args);
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('set_request_var')) {
|
||||
function set_request_var($name, $val) {
|
||||
$_REQUEST[$name] = $val;
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('srv')) {
|
||||
function srv($name, $val) {
|
||||
$_REQUEST[$name] = $val;
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('cacti_strtolower')) {
|
||||
function cacti_strtolower($string) {
|
||||
return mb_strtolower($string);
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('read_config_option')) {
|
||||
function read_config_option($name) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('read_user_setting')) {
|
||||
function read_user_setting($name) {
|
||||
return '08:00';
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('cacti_count')) {
|
||||
function cacti_count($array) {
|
||||
return ($array === false || !is_array($array)) ? 0 : count($array);
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('clean_up_lines')) {
|
||||
// Production version strips comments; the unit form only trims whitespace.
|
||||
function clean_up_lines($s) {
|
||||
return trim((string)$s);
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('raise_message')) {
|
||||
function raise_message($message_id, $message = '', $message_level = 0, $message_title = null) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('cacti_debug_backtrace')) {
|
||||
function cacti_debug_backtrace($entry = '', $html = false, $record = true, $limit = 0, $skip = 0) {
|
||||
return '';
|
||||
}
|
||||
}
|
||||
|
||||
if (!function_exists('get_debug_prefix')) {
|
||||
function get_debug_prefix() {
|
||||
return '';
|
||||
}
|
||||
}
|
||||
|
||||
// Constants required by lib/database.php logging paths and message helpers.
|
||||
if (!defined('POLLER_VERBOSITY_DEBUG')) { define('POLLER_VERBOSITY_DEBUG', 5); }
|
||||
if (!defined('POLLER_VERBOSITY_DEVDBG')) { define('POLLER_VERBOSITY_DEVDBG', 6); }
|
||||
if (!defined('MESSAGE_LEVEL_NONE')) { define('MESSAGE_LEVEL_NONE', 0); }
|
||||
if (!defined('MESSAGE_LEVEL_ERROR')) { define('MESSAGE_LEVEL_ERROR', 3); }
|
||||
if (!defined('POLLER_ID')) { define('POLLER_ID', 1); }
|
||||
@@ -0,0 +1,18 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
// Pest bootstrap: bind PHPUnit\Framework\TestCase to all suites under tests/Unit
|
||||
// and tests/integration so test files can use Pest's it()/test() syntax or plain
|
||||
// PHPUnit class style interchangeably.
|
||||
uses(PHPUnit\Framework\TestCase::class)->in('Unit', 'integration');
|
||||
@@ -0,0 +1,29 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/Helpers/UnitStubs.php';
|
||||
require_once dirname(__DIR__, 2) . '/lib/rrd.php';
|
||||
|
||||
it('escapes rrdtool strings correctly', function () {
|
||||
expect(rrdtool_escape_string('Normal String'))->toBe('Normal String');
|
||||
expect(rrdtool_escape_string('String with "quotes"'))->toBe('String with \"quotes\"');
|
||||
expect(rrdtool_escape_string('String with :colons:'))->toBe('String with \:colons\:');
|
||||
});
|
||||
|
||||
it('escapes percent signs only when ignore_percent is false', function () {
|
||||
// Default ($ignore_percent = true): % is left as-is.
|
||||
expect(rrdtool_escape_string('100%', true))->toBe('100%');
|
||||
// Explicit false: % is doubled to %% for rrdtool format escaping.
|
||||
expect(rrdtool_escape_string('100%', false))->toBe('100%%');
|
||||
});
|
||||
@@ -0,0 +1,83 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
// UnitStubs MUST be loaded before lib/time.php so srv() and other helpers are
|
||||
// resolvable when shift_time() is exercised.
|
||||
require_once dirname(__DIR__) . '/Helpers/UnitStubs.php';
|
||||
require_once dirname(__DIR__, 2) . '/include/global_constants.php';
|
||||
require_once dirname(__DIR__, 2) . '/lib/time.php';
|
||||
|
||||
it('calculates the last hour correctly', function () {
|
||||
$now = strtotime('2023-01-01 12:00:00');
|
||||
$span = [];
|
||||
get_timespan($span, $now, GT_LAST_HOUR, 1);
|
||||
|
||||
expect($span['begin_now'])->toBe(strtotime('2023-01-01 11:00:00'));
|
||||
expect($span['end_now'])->toBe($now);
|
||||
});
|
||||
|
||||
it('calculates today correctly', function () {
|
||||
$now = strtotime('2023-01-01 12:34:56');
|
||||
$span = [];
|
||||
get_timespan($span, $now, GT_THIS_DAY, 1);
|
||||
|
||||
expect($span['begin_now'])->toBe(strtotime('2023-01-01 00:00:00'));
|
||||
expect($span['end_now'])->toBe(strtotime('2023-01-01 23:59:59'));
|
||||
});
|
||||
|
||||
it('calculates this week correctly (Monday start)', function () {
|
||||
// 2023-01-04 is a Wednesday
|
||||
$now = strtotime('2023-01-04 12:00:00');
|
||||
$span = [];
|
||||
get_timespan($span, $now, GT_THIS_WEEK, 1); // 1 = Monday
|
||||
|
||||
expect($span['begin_now'])->toBe(strtotime('2023-01-02 00:00:00')); // Previous Monday
|
||||
expect($span['end_now'])->toBe(strtotime('2023-01-08 23:59:59')); // Next Sunday
|
||||
});
|
||||
|
||||
it('detects month boundaries correctly', function () {
|
||||
$span = [
|
||||
'begin_now' => strtotime('2023-01-01 00:00:00'),
|
||||
'end_now' => strtotime('2023-01-31 23:59:59')
|
||||
];
|
||||
|
||||
expect(check_month_boundaries($span))->toBeTrue();
|
||||
});
|
||||
|
||||
it('detects non-month boundaries correctly', function () {
|
||||
$span = [
|
||||
'begin_now' => strtotime('2023-01-02 00:00:00'),
|
||||
'end_now' => strtotime('2023-01-31 23:59:59')
|
||||
];
|
||||
|
||||
expect(check_month_boundaries($span))->toBeFalse();
|
||||
});
|
||||
|
||||
it('shifts time correctly', function () {
|
||||
$span = [
|
||||
'begin_now' => strtotime('2023-01-01 12:00:00'),
|
||||
'end_now' => strtotime('2023-01-01 13:00:00'),
|
||||
'current_value_date1' => '2023-01-01 12:00',
|
||||
'current_value_date2' => '2023-01-01 13:00'
|
||||
];
|
||||
|
||||
// Stub global and session for shift_time
|
||||
global $config;
|
||||
$_SESSION = [];
|
||||
|
||||
shift_time($span, '-', '1 hour');
|
||||
|
||||
expect($span['begin_now'])->toBe(strtotime('2023-01-01 11:00:00'));
|
||||
expect($span['end_now'])->toBe(strtotime('2023-01-01 12:00:00'));
|
||||
});
|
||||
@@ -0,0 +1,28 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
require_once dirname(__DIR__) . '/Helpers/UnitStubs.php';
|
||||
|
||||
it('cacti_sizeof handles various inputs', function () {
|
||||
expect(cacti_sizeof([1, 2, 3]))->toBe(3);
|
||||
expect(cacti_sizeof([]))->toBe(0);
|
||||
expect(cacti_sizeof(false))->toBe(0);
|
||||
expect(cacti_sizeof(null))->toBe(0);
|
||||
expect(cacti_sizeof('not an array'))->toBe(0);
|
||||
});
|
||||
|
||||
it('cacti_count handles various inputs', function () {
|
||||
expect(cacti_count([1, 2]))->toBe(2);
|
||||
expect(cacti_count(false))->toBe(0);
|
||||
});
|
||||
@@ -0,0 +1,51 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
if (!file_exists(dirname(__DIR__, 2) . '/lib/CactiProcess.php')) {
|
||||
test('CactiProcess integration: feature not present on this branch', function () {})
|
||||
->skip('lib/CactiProcess.php absent — feature PR #7073 not merged into develop yet');
|
||||
return;
|
||||
}
|
||||
|
||||
require_once __DIR__ . '/../../lib/CactiProcess.php';
|
||||
|
||||
test('Integration: CactiProcess::run executes echo successfully', function () {
|
||||
$process = \Cacti\Process\CactiProcess::run(['echo', '-n', 'cacti-ok']);
|
||||
expect($process->getExitCode())->toBe(0);
|
||||
expect($process->getOutput())->toBe('cacti-ok');
|
||||
});
|
||||
|
||||
test('Integration: CactiProcess::run captures stderr separately', function () {
|
||||
$process = \Cacti\Process\CactiProcess::run(['sh', '-c', 'echo err >&2; echo out']);
|
||||
expect($process->getOutput())->toContain('out');
|
||||
expect($process->getErrorOutput())->toContain('err');
|
||||
});
|
||||
|
||||
test('Integration: CactiProcess::run with MYSQL_PWD env does not put password in argv', function () {
|
||||
// Ensure MYSQL_PWD is set via env, not via argv
|
||||
$argv = ['mysqladmin', '--version'];
|
||||
$env = ['MYSQL_PWD' => 'secret123'];
|
||||
|
||||
// We inspect the argv - the password should NOT appear as an arg
|
||||
$containsPassword = in_array('--password=secret123', $argv) || in_array('-psecret123', $argv);
|
||||
expect($containsPassword)->toBeFalse();
|
||||
|
||||
// The env array carries the credential
|
||||
expect($env)->toHaveKey('MYSQL_PWD');
|
||||
expect($env['MYSQL_PWD'])->toBe('secret123');
|
||||
});
|
||||
|
||||
test('Integration: CactiProcess::run handles nonexistent command gracefully', function () {
|
||||
try {
|
||||
$process = \Cacti\Process\CactiProcess::run(['/nonexistent/binary/cacti_test_xyz']);
|
||||
// If it doesn't throw, exit code should indicate failure
|
||||
expect($process->getExitCode())->not->toBe(0);
|
||||
} catch (\Symfony\Component\Process\Exception\ProcessFailedException | \Exception $e) {
|
||||
expect($e)->toBeInstanceOf(\Exception::class);
|
||||
}
|
||||
expect(true)->toBeTrue(); // reaches here = handled
|
||||
});
|
||||
@@ -0,0 +1,50 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
| |
|
||||
| This program is distributed in the hope that it will be useful, |
|
||||
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||||
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||||
| GNU General Public License for more details. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
if (!file_exists(dirname(__DIR__, 2) . '/lib/CactiProcess.php')) {
|
||||
test('db_dump_data integration: CactiProcess feature not present on this branch', function () {})
|
||||
->skip('lib/CactiProcess.php absent — feature PR #7073 not merged into develop yet');
|
||||
return;
|
||||
}
|
||||
|
||||
require_once dirname(__DIR__, 2) . '/lib/database.php';
|
||||
require_once dirname(__DIR__, 2) . '/lib/functions.php';
|
||||
|
||||
test('db_dump_data executes and handles output file via Symfony Process', function () {
|
||||
// We need some Cacti globals to avoid fatal errors in db_dump_data
|
||||
global $database_default, $database_username, $database_password;
|
||||
$database_default = 'cacti';
|
||||
$database_username = 'cactiuser';
|
||||
$database_password = 'cactipassword';
|
||||
|
||||
$temp_file = tempnam(sys_get_temp_dir(), 'cacti_dump_test');
|
||||
|
||||
// Mock a scenario where mysqldump might not be available or fails
|
||||
// But we want to test the wrapper's logic for opening files and calling Symfony Process.
|
||||
|
||||
// Since we can't easily mock the binary on this environment, we'll test the path logic.
|
||||
$retval = db_dump_data('test_db', '', [], $temp_file, '--version');
|
||||
|
||||
// Even if it fails (exit code 1 or 127), we verify it attempted to write/touch the file
|
||||
// or logged the correct errors.
|
||||
expect(file_exists($temp_file))->toBeTrue();
|
||||
|
||||
// nosemgrep: php.lang.security.unlink-use.unlink-use - tempnam() output, not user input
|
||||
unlink($temp_file);
|
||||
});
|
||||
@@ -0,0 +1,55 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
| |
|
||||
| This program is free software; you can redistribute it and/or |
|
||||
| modify it under the terms of the GNU General Public License |
|
||||
| as published by the Free Software Foundation; either version 2 |
|
||||
| of the License, or (at your option) any later version. |
|
||||
+-------------------------------------------------------------------------+
|
||||
| Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
$orb_available = static function (): bool {
|
||||
// nosemgrep: php.lang.security.exec-use.exec-use - constant command, integration test
|
||||
return trim((string)shell_exec('command -v orb 2>/dev/null')) !== '';
|
||||
};
|
||||
|
||||
$has_timeout = static function (): bool {
|
||||
// nosemgrep: php.lang.security.exec-use.exec-use - constant command, integration test
|
||||
return trim((string)shell_exec('command -v timeout 2>/dev/null')) !== '';
|
||||
};
|
||||
|
||||
it('has all required PHP extensions in the Orb machine', function () use ($orb_available, $has_timeout) {
|
||||
if (!$orb_available()) {
|
||||
test()->markTestSkipped('orb CLI not available');
|
||||
}
|
||||
|
||||
$required_exts = [
|
||||
'gd', 'gmp', 'intl', 'ldap', 'mbstring', 'mysqli',
|
||||
'pdo_mysql', 'snmp', 'pcntl', 'posix', 'sockets',
|
||||
'xml', 'dom', 'sqlite3', 'pdo_sqlite'
|
||||
];
|
||||
|
||||
foreach ($required_exts as $ext) {
|
||||
// Extension names come from a fixed allowlist; no external input.
|
||||
$cmd = ($has_timeout() ? 'timeout 30 ' : '') . 'orb php -m | grep -i ^' . escapeshellarg($ext) . '$';
|
||||
// nosemgrep: php.lang.security.exec-use.exec-use - allowlisted ext names, integration test
|
||||
$output = shell_exec($cmd);
|
||||
expect(trim((string)$output))->toBeIgnoringCase($ext);
|
||||
}
|
||||
});
|
||||
|
||||
it('can run a Cacti CLI command in the Orb machine', function () use ($orb_available, $has_timeout) {
|
||||
if (!$orb_available()) {
|
||||
test()->markTestSkipped('orb CLI not available');
|
||||
}
|
||||
|
||||
$cmd = ($has_timeout() ? 'timeout 30 ' : '') . 'orb php cli/check_cli_version.sh';
|
||||
// nosemgrep: php.lang.security.exec-use.exec-use - constant command, integration test
|
||||
$output = shell_exec($cmd);
|
||||
// Just verify it doesn't crash and returns something sensible
|
||||
expect($output)->toContain('Cacti');
|
||||
});
|
||||
@@ -0,0 +1,33 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
if (!file_exists(dirname(__DIR__, 2) . '/lib/CactiProcess.php')) {
|
||||
test('Net_Ping integration: CactiProcess feature not present on this branch', function () {})
|
||||
->skip('lib/CactiProcess.php absent — feature PR #7073 not merged into develop yet');
|
||||
return;
|
||||
}
|
||||
|
||||
require_once dirname(__DIR__, 2) . '/lib/ping.php';
|
||||
require_once dirname(__DIR__, 2) . '/lib/functions.php';
|
||||
|
||||
test('Net_Ping::ping_icmp handles fping-style output through CactiProcess', function () {
|
||||
// Mock a Net_Ping object
|
||||
$ping = new Net_Ping();
|
||||
$ping->host = ['hostname' => '127.0.0.1'];
|
||||
$ping->timeout = 500;
|
||||
$ping->retries = 1;
|
||||
|
||||
// Since we can't easily mock the shell command output in this environment without a full mock framework,
|
||||
// we'll focus on ensuring the logic doesn't crash and correctly initializes.
|
||||
|
||||
// We check if the ping logic can resolve a local address
|
||||
$ping->ping_icmp();
|
||||
|
||||
// The result depends on whether fping/ping exists in the environment.
|
||||
// We mostly want to verify that our refactor doesn't cause a fatal error.
|
||||
expect($ping->ping_response)->not->toBeEmpty();
|
||||
});
|
||||
@@ -0,0 +1,57 @@
|
||||
<?php
|
||||
/*
|
||||
+-------------------------------------------------------------------------+
|
||||
| Copyright (C) 2004-2026 The Cacti Group |
|
||||
+-------------------------------------------------------------------------+
|
||||
*/
|
||||
|
||||
if (!file_exists(dirname(__DIR__, 2) . '/lib/CactiProcess.php')) {
|
||||
test('SQL scripts integration: CactiProcess feature not present on this branch', function () {})
|
||||
->skip('lib/CactiProcess.php absent — feature PR #7073 not merged into develop yet');
|
||||
return;
|
||||
}
|
||||
|
||||
test('Integration: scripts/sql.php file contains no shell_exec calls', function () {
|
||||
$path = __DIR__ . '/../../scripts/sql.php';
|
||||
if (!file_exists($path)) {
|
||||
expect(true)->toBeTrue();
|
||||
return;
|
||||
}
|
||||
$contents = file_get_contents($path);
|
||||
expect($contents)->not->toContain('shell_exec(');
|
||||
expect($contents)->toContain('CactiProcess');
|
||||
});
|
||||
|
||||
test('Integration: scripts/ss_sql.php file contains no shell_exec calls', function () {
|
||||
$path = __DIR__ . '/../../scripts/ss_sql.php';
|
||||
if (!file_exists($path)) {
|
||||
expect(true)->toBeTrue();
|
||||
return;
|
||||
}
|
||||
$contents = file_get_contents($path);
|
||||
expect($contents)->not->toContain('shell_exec(');
|
||||
expect($contents)->toContain('CactiProcess');
|
||||
});
|
||||
|
||||
test('Integration: lib/ping.php passes argv array not concatenated string', function () {
|
||||
$path = __DIR__ . '/../../lib/ping.php';
|
||||
if (!file_exists($path)) {
|
||||
expect(true)->toBeTrue();
|
||||
return;
|
||||
}
|
||||
$contents = file_get_contents($path);
|
||||
// Old pattern used string concatenation with cacti_escapeshellarg
|
||||
expect($contents)->not->toContain("shell_exec(cacti_escapeshellarg(\$fping)");
|
||||
expect($contents)->toContain('CactiProcess::run(');
|
||||
});
|
||||
|
||||
test('Integration: poller_realtime.php uses CactiProcess not shell_exec', function () {
|
||||
$path = __DIR__ . '/../../poller_realtime.php';
|
||||
if (!file_exists($path)) {
|
||||
expect(true)->toBeTrue();
|
||||
return;
|
||||
}
|
||||
$contents = file_get_contents($path);
|
||||
expect($contents)->not->toContain('shell_exec("$command_string');
|
||||
expect($contents)->toContain('CactiProcess::run(');
|
||||
});
|
||||
Executable
+149
@@ -0,0 +1,149 @@
|
||||
#!/usr/bin/env bash
|
||||
# +-------------------------------------------------------------------------+
|
||||
# | Copyright (C) 2004-2026 The Cacti Group |
|
||||
# | |
|
||||
# | This program is free software; you can redistribute it and/or |
|
||||
# | modify it under the terms of the GNU General Public License |
|
||||
# | as published by the Free Software Foundation; either version 2 |
|
||||
# | of the License, or (at your option) any later version. |
|
||||
# | |
|
||||
# | This program is distributed in the hope that it will be useful, |
|
||||
# | but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
||||
# | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
||||
# | GNU General Public License for more details. |
|
||||
# +-------------------------------------------------------------------------+
|
||||
# | Cacti: The Complete RRDtool-based Graphing Solution |
|
||||
# +-------------------------------------------------------------------------+
|
||||
# | This code is designed, written, and maintained by the Cacti Group. See |
|
||||
# | about.php and/or the AUTHORS file for specific developer information. |
|
||||
# +-------------------------------------------------------------------------+
|
||||
# | http://www.cacti.net/ |
|
||||
# +-------------------------------------------------------------------------+
|
||||
set -euo pipefail
|
||||
|
||||
# Smoke test for Docker dev environment.
|
||||
# Builds, starts, validates, tears down. Exit 0 = pass, 1 = fail.
|
||||
|
||||
COMPOSE_PROJECT="cacti_test_$$"
|
||||
SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
|
||||
REPO_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
|
||||
WEB_PORT=18080
|
||||
PASS=0
|
||||
FAIL=0
|
||||
|
||||
cleanup() {
|
||||
cd "$REPO_DIR"
|
||||
docker compose -p "$COMPOSE_PROJECT" down -v --remove-orphans 2>/dev/null || true
|
||||
# Only remove the .env.test file this script created. We must NEVER touch
|
||||
# $REPO_DIR/include/config.php on the host; that is the developer's real
|
||||
# Cacti configuration and is never written by this smoke test.
|
||||
rm -f "$REPO_DIR/.env.test"
|
||||
}
|
||||
trap cleanup EXIT
|
||||
|
||||
log_pass() { echo "[PASS] $1"; PASS=$((PASS + 1)); }
|
||||
log_fail() { echo "[FAIL] $1"; FAIL=$((FAIL + 1)); }
|
||||
|
||||
check() {
|
||||
local desc="$1"; shift
|
||||
if "$@" >/dev/null 2>&1; then
|
||||
log_pass "$desc"
|
||||
else
|
||||
log_fail "$desc"
|
||||
fi
|
||||
}
|
||||
|
||||
cd "$REPO_DIR"
|
||||
|
||||
# Generate test env
|
||||
cat > .env.test <<EOF
|
||||
WEB_PORT=$WEB_PORT
|
||||
DB_ROOT_PASSWORD=testroot
|
||||
DB_NAME=cacti
|
||||
DB_USER=cacti
|
||||
DB_PASSWORD=testpass
|
||||
DB_PORT=13306
|
||||
TIMEZONE=UTC
|
||||
PHP_MEMORY_LIMIT=256M
|
||||
DB_MAX_CONNECTIONS=50
|
||||
DB_BUFFER_POOL_SIZE=256M
|
||||
EOF
|
||||
|
||||
echo "=== Docker smoke test ==="
|
||||
|
||||
# 1. Build
|
||||
echo "Building image..."
|
||||
if docker compose -p "$COMPOSE_PROJECT" --env-file .env.test build --quiet 2>&1; then
|
||||
log_pass "Image builds"
|
||||
else
|
||||
log_fail "Image builds"
|
||||
echo "Build failed, aborting."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# 2. Start
|
||||
echo "Starting containers..."
|
||||
docker compose -p "$COMPOSE_PROJECT" --env-file .env.test up -d 2>&1
|
||||
|
||||
# 3. Wait for healthy (up to 120s)
|
||||
echo "Waiting for containers..."
|
||||
TRIES=0
|
||||
while [ $TRIES -lt 24 ]; do
|
||||
DB_HEALTH=$(docker compose -p "$COMPOSE_PROJECT" ps --format json 2>/dev/null | grep -o '"Health":"[^"]*"' | head -1 | cut -d'"' -f4)
|
||||
WEB_HEALTH=$(docker compose -p "$COMPOSE_PROJECT" ps --format json 2>/dev/null | grep -o '"Health":"[^"]*"' | tail -1 | cut -d'"' -f4)
|
||||
if [ "$DB_HEALTH" = "healthy" ] && [ "$WEB_HEALTH" = "healthy" ]; then
|
||||
break
|
||||
fi
|
||||
sleep 5
|
||||
TRIES=$((TRIES + 1))
|
||||
done
|
||||
|
||||
WEB_CONTAINER=$(docker compose -p "$COMPOSE_PROJECT" ps -q web 2>/dev/null)
|
||||
|
||||
check "DB container healthy" [ "$DB_HEALTH" = "healthy" ]
|
||||
check "Web container healthy" [ "$WEB_HEALTH" = "healthy" ]
|
||||
|
||||
# 4. PHP extensions
|
||||
REQUIRED_EXTS="gd gmp intl ldap mbstring mysqli pdo_mysql snmp pcntl posix sockets xml dom sqlite3 pdo_sqlite"
|
||||
LOADED=$(docker exec "$WEB_CONTAINER" php -m 2>/dev/null)
|
||||
for ext in $REQUIRED_EXTS; do
|
||||
if echo "$LOADED" | grep -qi "^${ext}$"; then
|
||||
log_pass "PHP ext: $ext"
|
||||
else
|
||||
log_fail "PHP ext: $ext"
|
||||
fi
|
||||
done
|
||||
|
||||
# 5. config.php generated
|
||||
check "config.php exists" docker exec "$WEB_CONTAINER" test -f /var/www/html/cacti/include/config.php
|
||||
check "config.php has DB host" docker exec "$WEB_CONTAINER" grep -q "database_hostname" /var/www/html/cacti/include/config.php
|
||||
|
||||
# 6. Cron
|
||||
check "Cron job installed" docker exec "$WEB_CONTAINER" test -f /etc/cron.d/cacti-poller
|
||||
check "Cron daemon running" docker exec "$WEB_CONTAINER" pgrep cron
|
||||
|
||||
# 7. HTTP response
|
||||
HTTP_CODE=$(curl -so /dev/null -w "%{http_code}" "http://localhost:${WEB_PORT}/cacti/" 2>/dev/null || echo "000")
|
||||
check "HTTP 200 on /cacti/" [ "$HTTP_CODE" = "200" ]
|
||||
|
||||
# 8. Security headers
|
||||
HEADERS=$(curl -sI "http://localhost:${WEB_PORT}/cacti/" 2>/dev/null)
|
||||
check "Header: X-Content-Type-Options" grep -qi "X-Content-Type-Options" <<<"$HEADERS"
|
||||
check "Header: X-Frame-Options" grep -qi "X-Frame-Options" <<<"$HEADERS"
|
||||
check "Header: Referrer-Policy" grep -qi "Referrer-Policy" <<<"$HEADERS"
|
||||
check "Header: Permissions-Policy" grep -qi "Permissions-Policy" <<<"$HEADERS"
|
||||
if grep -qi "X-Powered-By" <<<"$HEADERS"; then
|
||||
log_fail "No X-Powered-By leak"
|
||||
else
|
||||
log_pass "No X-Powered-By leak"
|
||||
fi
|
||||
|
||||
# 9. DB accessible from web
|
||||
check "DB connection from web" docker exec "$WEB_CONTAINER" php -r "new PDO('mysql:host=db;dbname=cacti', 'cacti', 'testpass');"
|
||||
|
||||
echo ""
|
||||
echo "=== Results ==="
|
||||
echo "Passed: $PASS"
|
||||
echo "Failed: $FAIL"
|
||||
|
||||
[ "$FAIL" -eq 0 ] && exit 0 || exit 1
|
||||
Reference in new issue
Block a user