baf971ba54
Diag: surfaces `risk_stack.eval_warmup.{remaining,active,blend,
floor_*,target_*}` so the v9 defensive-warmup window is observable
in diag.jsonl. `remaining` is the counter; `blend` is the
defensive-vs-normal mix coefficient (1.0 = full defensive, 0.0 =
normal); `floor_*` reflect the LIVE override values (read AFTER the
warmup kernel ran). Pre-warmup the kernel is a no-op (remaining=-1),
so v9 train-phase diag is bit-identical to v8.
Cleanup: tightens unreachable_pub items in tests/behavioral/* and
tests/sp5_producer_unit_tests.rs (pub → pub(crate)), removes
unused_mut on 6 sp5 scratch buffers, renames unused `step` loop
counter in alpha_baseline example, and explicitly discards an
intentionally-no-op `Command::assert` in cli_integration_test.
Reduces lint count by ~25; remaining 3 dead_code warnings flag
SP15 Phase 2A behavioral scaffolding (Phase 2B never landed —
deliberate signal, not noise).
Pre-existing pearl per feedback_no_hiding: do NOT suppress these
with #[allow]; the warnings ARE the design call surface.
297 lines
8.8 KiB
Rust
297 lines
8.8 KiB
Rust
//! FXT CLI Integration Tests
|
|
//!
|
|
//! Tests CLI argument parsing, command routing, and error handling for the FXT binary.
|
|
//! These tests use `assert_cmd` to invoke the FXT binary and verify behavior.
|
|
|
|
// Suppress false-positive unused_crate_dependencies warnings
|
|
// dev-dependencies are shared across ALL test targets in the crate
|
|
// This test may not use all deps, but they are required by other integration tests
|
|
#![allow(unused_crate_dependencies)]
|
|
#![allow(clippy::tests_outside_test_module, clippy::str_to_string, clippy::non_ascii_literal, clippy::shadow_unrelated, clippy::shadow_reuse, clippy::unwrap_used, clippy::expect_used, clippy::assertions_on_result_states, clippy::use_debug, clippy::let_underscore_must_use, clippy::string_add, clippy::string_add_assign, clippy::wildcard_enum_match_arm, clippy::unseparated_literal_suffix, clippy::indexing_slicing, clippy::doc_markdown, clippy::similar_names, clippy::impl_trait_in_params, unused_imports, dead_code, clippy::panic, clippy::redundant_clone)]
|
|
|
|
use assert_cmd::Command;
|
|
use predicates::prelude::*;
|
|
|
|
/// Test that FXT binary can be invoked with --help
|
|
#[test]
|
|
fn test_fxt_help() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("--help")
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains(
|
|
"Foxhunt Trading System Terminal Interface",
|
|
))
|
|
.stdout(predicate::str::contains("--api-url"))
|
|
.stdout(predicate::str::contains("--log-level"));
|
|
}
|
|
|
|
/// Test tune command help output
|
|
#[test]
|
|
fn test_tune_help() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("tune")
|
|
.arg("--help")
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains(
|
|
"Start, monitor, and manage hyperparameter tuning",
|
|
));
|
|
}
|
|
|
|
/// Test tune start command help
|
|
#[test]
|
|
fn test_tune_start_help() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("tune")
|
|
.arg("start")
|
|
.arg("--help")
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains("--model"))
|
|
.stdout(predicate::str::contains("--trials"));
|
|
}
|
|
|
|
/// Test tune status command help
|
|
#[test]
|
|
fn test_tune_status_help() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("tune")
|
|
.arg("status")
|
|
.arg("--help")
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains("--job-id"));
|
|
}
|
|
|
|
/// Test auth command help output
|
|
#[test]
|
|
fn test_auth_help() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("auth")
|
|
.arg("--help")
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains(
|
|
"Login, logout, and manage authentication tokens",
|
|
));
|
|
}
|
|
|
|
/// Test auth login command help
|
|
#[test]
|
|
fn test_auth_login_help() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("auth")
|
|
.arg("login")
|
|
.arg("--help")
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains("--username"));
|
|
}
|
|
|
|
/// Test auth status command (no authentication required)
|
|
#[test]
|
|
fn test_auth_status_no_auth() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("auth")
|
|
.arg("status")
|
|
.assert()
|
|
.success() // Should succeed even without authentication
|
|
.stdout(predicate::str::contains("Authentication Status"));
|
|
}
|
|
|
|
/// Test auth logout command (no authentication required)
|
|
#[test]
|
|
fn test_auth_logout_no_auth() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("auth")
|
|
.arg("logout")
|
|
.assert()
|
|
.success() // Should succeed even if not logged in
|
|
.stdout(predicate::str::contains("Logged out"));
|
|
}
|
|
|
|
/// Test that tune commands require authentication
|
|
/// This test expects failure when not authenticated
|
|
#[test]
|
|
fn test_tune_requires_auth() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("tune")
|
|
.arg("status")
|
|
.arg("--job-id")
|
|
.arg("550e8400-e29b-41d4-a716-446655440000")
|
|
.assert()
|
|
.failure() // Should fail without authentication
|
|
.stderr(predicate::str::contains("Not authenticated"));
|
|
}
|
|
|
|
/// Test environment variable support for API URL
|
|
#[test]
|
|
fn test_env_var_api_url() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.env("API_URL", "http://test.example.com:50051")
|
|
.arg("--help")
|
|
.assert()
|
|
.success();
|
|
}
|
|
|
|
/// Test environment variable support for log level
|
|
#[test]
|
|
fn test_env_var_log_level() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.env("FXT_LOG_LEVEL", "debug")
|
|
.arg("--help")
|
|
.assert()
|
|
.success();
|
|
}
|
|
|
|
/// Test CLI flag precedence over environment variables
|
|
#[test]
|
|
fn test_cli_flag_precedence() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.env("API_GATEWAY_URL", "http://env.example.com")
|
|
.arg("--api-url")
|
|
.arg("http://cli.example.com")
|
|
.arg("--help")
|
|
.assert()
|
|
.success();
|
|
}
|
|
|
|
/// Test invalid command
|
|
#[test]
|
|
fn test_invalid_command() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("invalid_command")
|
|
.assert()
|
|
.failure()
|
|
.stderr(predicate::str::contains("error"));
|
|
}
|
|
|
|
/// Test tune start with invalid model type
|
|
#[test]
|
|
fn test_tune_start_invalid_model() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("tune")
|
|
.arg("start")
|
|
.arg("--model")
|
|
.arg("INVALID_MODEL_TYPE")
|
|
.arg("--trials")
|
|
.arg("10")
|
|
.assert()
|
|
.failure(); // Should fail validation (even before auth check)
|
|
}
|
|
|
|
/// Test tune start missing required argument
|
|
#[test]
|
|
fn test_tune_start_missing_trials() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("tune")
|
|
.arg("start")
|
|
.arg("--model")
|
|
.arg("DQN")
|
|
// Missing --trials argument (but has default, so will fail on auth instead)
|
|
.assert()
|
|
.failure() // Will fail due to authentication requirement
|
|
.stderr(predicate::str::contains("Not authenticated"));
|
|
}
|
|
|
|
/// Test tune status with malformed UUID
|
|
#[test]
|
|
fn test_tune_status_invalid_uuid() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("tune")
|
|
.arg("status")
|
|
.arg("--job-id")
|
|
.arg("not-a-valid-uuid")
|
|
.assert()
|
|
.failure() // Should fail (either auth check or UUID validation)
|
|
.stderr(predicate::str::contains("").or(predicate::str::contains(""))); // Error may vary
|
|
}
|
|
|
|
/// Test dashboard command (without launching terminal)
|
|
/// Note: This test will fail if it actually tries to launch the TUI,
|
|
/// but helps verify command parsing
|
|
#[test]
|
|
#[ignore = "Ignored because it tries to launch terminal UI"]
|
|
fn test_dashboard_command() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
let _ = cmd.arg("dashboard")
|
|
.timeout(std::time::Duration::from_secs(2))
|
|
.assert();
|
|
// Will timeout or fail trying to connect, but that's expected — assert result
|
|
// intentionally discarded; this test verifies arg parsing reaches launch.
|
|
}
|
|
|
|
/// Test version flag
|
|
#[test]
|
|
fn test_version_flag() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("--version")
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains("fxt"));
|
|
}
|
|
|
|
/// Test that all valid tune models are accepted by help
|
|
#[test]
|
|
fn test_tune_valid_models_in_help() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("tune")
|
|
.arg("start")
|
|
.arg("--help")
|
|
.assert()
|
|
.success();
|
|
// Help should display without errors, model validation happens at runtime
|
|
}
|
|
|
|
/// Test tune best command help
|
|
#[test]
|
|
fn test_tune_best_help() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("tune")
|
|
.arg("best")
|
|
.arg("--help")
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains("--job-id"))
|
|
.stdout(predicate::str::contains("--export"));
|
|
}
|
|
|
|
/// Test tune stop command help
|
|
#[test]
|
|
fn test_tune_stop_help() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("tune")
|
|
.arg("stop")
|
|
.arg("--help")
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains("--job-id"))
|
|
.stdout(predicate::str::contains("--reason"));
|
|
}
|
|
|
|
/// Test multiple CLI flags together
|
|
#[test]
|
|
fn test_multiple_cli_flags() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("--api-url")
|
|
.arg("http://test.example.com")
|
|
.arg("--log-level")
|
|
.arg("debug")
|
|
.arg("--help")
|
|
.assert()
|
|
.success();
|
|
}
|
|
|
|
/// Test auth refresh command help
|
|
#[test]
|
|
fn test_auth_refresh_help() {
|
|
let mut cmd = Command::cargo_bin("fxt").unwrap();
|
|
cmd.arg("auth")
|
|
.arg("refresh")
|
|
.arg("--help")
|
|
.assert()
|
|
.success()
|
|
.stdout(predicate::str::contains("Refresh access token"));
|
|
}
|