Enum UserProfile 

pub enum UserProfile {
    PowerUser,
    Gamer,
    Streamer,
    RemoteWorker,
    Casual,
}

Pre-defined user profiles.

Example

use netspeed_cli::profiles::UserProfile;

// Parse from a string name
assert_eq!(UserProfile::from_name("gamer"), Some(UserProfile::Gamer));
assert_eq!(UserProfile::from_name("streamer"), Some(UserProfile::Streamer));
assert_eq!(UserProfile::from_name("invalid"), None);

// Round-trip: name() → from_name()
assert_eq!(UserProfile::from_name(UserProfile::RemoteWorker.name()), Some(UserProfile::RemoteWorker));

// Default is PowerUser
assert_eq!(UserProfile::default(), UserProfile::PowerUser);

Variants

PowerUser

Tech-savvy users who want all metrics and detailed analysis.

Gamer

Online gamers focused on latency, jitter, and bufferbloat.

Streamer

Content consumers (Netflix, YouTube, etc.) focused on download speed.

RemoteWorker

Work-from-home professionals focused on upload and stability.

Casual

Basic users who want a simple pass/fail assessment.

Implementations

impl UserProfile

pub const TYPE_NAME: &'static str = "profile"

Type identifier for error messages (DIP: shared validation pattern).

pub const VALID_NAMES: &'static [&'static str]

List of valid profile names for error messages.

pub fn from_name(name: &str) -> Option<Self>

Get profile from string name (case-insensitive).

Returns Some(UserProfile) for valid names (including aliases like "poweruser" and "remote"), or None for unrecognized names.

Example

use netspeed_cli::profiles::UserProfile;

// Canonical names
assert_eq!(UserProfile::from_name("power-user"), Some(UserProfile::PowerUser));
assert_eq!(UserProfile::from_name("gamer"), Some(UserProfile::Gamer));
assert_eq!(UserProfile::from_name("streamer"), Some(UserProfile::Streamer));
assert_eq!(UserProfile::from_name("remote-worker"), Some(UserProfile::RemoteWorker));
assert_eq!(UserProfile::from_name("casual"), Some(UserProfile::Casual));

// Aliases
assert_eq!(UserProfile::from_name("poweruser"), Some(UserProfile::PowerUser));
assert_eq!(UserProfile::from_name("remote"), Some(UserProfile::RemoteWorker));

// Case-insensitive
assert_eq!(UserProfile::from_name("GAMER"), Some(UserProfile::Gamer));
assert_eq!(UserProfile::from_name("Casual"), Some(UserProfile::Casual));

// Invalid names return None
assert_eq!(UserProfile::from_name("admin"), None);

pub fn is_valid_name(name: &str) -> bool

Check if a profile name is valid without returning the profile.

Example

use netspeed_cli::profiles::UserProfile;

// Canonical names are valid
assert!(UserProfile::is_valid_name("power-user"));
assert!(UserProfile::is_valid_name("gamer"));

// Aliases are also valid
assert!(UserProfile::is_valid_name("poweruser"));
assert!(UserProfile::is_valid_name("remote"));

// Case-insensitive
assert!(UserProfile::is_valid_name("GAMER"));

// Invalid names
assert!(!UserProfile::is_valid_name("admin"));
assert!(!UserProfile::is_valid_name(""));

pub fn validate(name: &str) -> Result<(), String>

Validate this profile name and return error message if invalid.

Returns Ok(()) if valid, Err(msg) with the list of valid options if invalid. Use this for config-file validation where you need an error message; use from_name() if you just need the UserProfile value.

Example

use netspeed_cli::profiles::UserProfile;

// Valid names pass validation
assert!(UserProfile::validate("power-user").is_ok());
assert!(UserProfile::validate("gamer").is_ok());
assert!(UserProfile::validate("streamer").is_ok());
assert!(UserProfile::validate("remote-worker").is_ok());
assert!(UserProfile::validate("casual").is_ok());

// Invalid names produce a descriptive error
let err = UserProfile::validate("admin").unwrap_err();
assert!(err.contains("Invalid profile"));
assert!(err.contains("admin"));
assert!(err.contains("gamer"));  // lists valid options

pub fn name(&self) -> &'static str

CLI-friendly name for the profile.

Example

use netspeed_cli::profiles::UserProfile;

assert_eq!(UserProfile::PowerUser.name(), "power-user");
assert_eq!(UserProfile::Gamer.name(), "gamer");
assert_eq!(UserProfile::Streamer.name(), "streamer");
assert_eq!(UserProfile::RemoteWorker.name(), "remote-worker");
assert_eq!(UserProfile::Casual.name(), "casual");

pub fn display_name(&self) -> &'static str

Display name with emoji for headers.

Example

use netspeed_cli::profiles::UserProfile;

assert_eq!(UserProfile::PowerUser.display_name(), "⚙️ Power User");
assert_eq!(UserProfile::Gamer.display_name(), "🎮 Gamer");
assert_eq!(UserProfile::Streamer.display_name(), "📺 Streamer");
assert_eq!(UserProfile::RemoteWorker.display_name(), "💼 Remote Worker");
assert_eq!(UserProfile::Casual.display_name(), "👤 Casual");

pub fn description(&self) -> &'static str

Description for help text.

Example

use netspeed_cli::profiles::UserProfile;

// Each description highlights the profile's focus
assert!(UserProfile::Gamer.description().contains("Latency"));
assert!(UserProfile::Gamer.description().contains("jitter"));

assert!(UserProfile::Streamer.description().contains("Download"));
assert!(UserProfile::Streamer.description().contains("streaming"));

assert!(UserProfile::RemoteWorker.description().contains("Upload"));
assert!(UserProfile::RemoteWorker.description().contains("video calls"));

assert!(UserProfile::Casual.description().contains("pass/fail"));

assert!(UserProfile::PowerUser.description().contains("All metrics"));

pub fn scoring_weights(&self) -> (f64, f64, f64, f64)

Scoring weights for overall connection rating (ping, jitter, download, upload).

Returns (ping_weight, jitter_weight, download_weight, upload_weight). Weights always sum to ~1.0, but the distribution reflects each profile’s priorities.

Example

use netspeed_cli::profiles::UserProfile;

// Gamer prioritizes latency and jitter
let (ping, jitter, dl, ul) = UserProfile::Gamer.scoring_weights();
assert!(ping > dl, "gamer weights ping over download");
assert!(jitter > ul, "gamer weights jitter over upload");

// Streamer prioritizes download speed
let (_, _, dl, _) = UserProfile::Streamer.scoring_weights();
assert!(dl >= 0.5, "streamer weights download highest");

// RemoteWorker prioritizes upload speed
let (_, _, _, ul) = UserProfile::RemoteWorker.scoring_weights();
assert!(ul >= 0.35, "remote-worker weights upload highest");

// All profiles' weights sum to ~1.0
for profile in [UserProfile::PowerUser, UserProfile::Gamer,
               UserProfile::Streamer, UserProfile::RemoteWorker,
               UserProfile::Casual] {
    let (p, j, d, u) = profile.scoring_weights();
    assert!((p + j + d + u - 1.0).abs() < 0.01,
            "weights must sum to ~1.0 for {profile:?}");
}

pub fn excellent_speed_threshold(&self) -> f64

Speed rating thresholds for “Excellent” (in Mbps).

Lower values = easier to achieve. PowerUser demands the highest bandwidth; Casual is satisfied with the least.

Example

use netspeed_cli::profiles::UserProfile;

// PowerUser requires 500 Mbps for "Excellent"
assert_eq!(UserProfile::PowerUser.excellent_speed_threshold(), 500.0);

// Gamer and RemoteWorker need only 100 Mbps (latency matters more)
assert_eq!(UserProfile::Gamer.excellent_speed_threshold(), 100.0);
assert_eq!(UserProfile::RemoteWorker.excellent_speed_threshold(), 100.0);

// Streamer needs 200 Mbps (4K streaming headroom)
assert_eq!(UserProfile::Streamer.excellent_speed_threshold(), 200.0);

// Casual is happy with 50 Mbps
assert_eq!(UserProfile::Casual.excellent_speed_threshold(), 50.0);

pub fn excellent_ping_threshold(&self) -> f64

Ping rating thresholds for “Excellent” (in ms).

Lower values = harder to achieve. Gamer demands ultra-low latency; Casual/Streamer tolerate higher ping.

Example

use netspeed_cli::profiles::UserProfile;

// Gamer needs ≤5 ms for "Excellent" ping
assert_eq!(UserProfile::Gamer.excellent_ping_threshold(), 5.0);

// PowerUser needs ≤10 ms
assert_eq!(UserProfile::PowerUser.excellent_ping_threshold(), 10.0);

// RemoteWorker tolerates ≤20 ms
assert_eq!(UserProfile::RemoteWorker.excellent_ping_threshold(), 20.0);

// Streamer and Casual are fine with ≤30 ms
assert_eq!(UserProfile::Streamer.excellent_ping_threshold(), 30.0);
assert_eq!(UserProfile::Casual.excellent_ping_threshold(), 30.0);

pub fn excellent_jitter_threshold(&self) -> f64

Jitter rating thresholds for “Excellent” (in ms).

Lower values = harder to achieve. Gamer needs the most consistent latency; Casual/Streamer tolerate more variation.

Example

use netspeed_cli::profiles::UserProfile;

// Gamer needs ≤1 ms jitter for "Excellent"
assert_eq!(UserProfile::Gamer.excellent_jitter_threshold(), 1.0);

// PowerUser needs ≤2 ms
assert_eq!(UserProfile::PowerUser.excellent_jitter_threshold(), 2.0);

// RemoteWorker tolerates ≤3 ms
assert_eq!(UserProfile::RemoteWorker.excellent_jitter_threshold(), 3.0);

// Streamer and Casual are fine with ≤5 ms
assert_eq!(UserProfile::Streamer.excellent_jitter_threshold(), 5.0);
assert_eq!(UserProfile::Casual.excellent_jitter_threshold(), 5.0);

pub fn show_latency_details(&self) -> bool

Whether to show detailed latency section.

All profiles except Casual show latency details.

Example

use netspeed_cli::profiles::UserProfile;

assert!(UserProfile::PowerUser.show_latency_details());
assert!(UserProfile::Gamer.show_latency_details());
assert!(!UserProfile::Casual.show_latency_details()); // minimal output

pub fn show_bufferbloat(&self) -> bool

Whether to show bufferbloat grade.

Only PowerUser and Gamer care about bufferbloat.

Example

use netspeed_cli::profiles::UserProfile;

assert!(UserProfile::PowerUser.show_bufferbloat());
assert!(UserProfile::Gamer.show_bufferbloat());
assert!(!UserProfile::Streamer.show_bufferbloat());
assert!(!UserProfile::Casual.show_bufferbloat());

pub fn show_stability(&self) -> bool

Whether to show stability analysis (CV%).

PowerUser and RemoteWorker need consistent connections for their use cases.

Example

use netspeed_cli::profiles::UserProfile;

assert!(UserProfile::PowerUser.show_stability());
assert!(UserProfile::RemoteWorker.show_stability());
assert!(!UserProfile::Gamer.show_stability());
assert!(!UserProfile::Casual.show_stability());

pub fn show_percentiles(&self) -> bool

Whether to show latency percentiles.

Only PowerUser sees percentile detail.

Example

use netspeed_cli::profiles::UserProfile;

assert!(UserProfile::PowerUser.show_percentiles());
assert!(!UserProfile::Gamer.show_percentiles());
assert!(!UserProfile::Casual.show_percentiles());

pub fn show_usage_check(&self) -> bool

Whether to show usage check targets.

All profiles except Casual show usage checks.

Example

use netspeed_cli::profiles::UserProfile;

assert!(UserProfile::PowerUser.show_usage_check());
assert!(UserProfile::Gamer.show_usage_check());
assert!(!UserProfile::Casual.show_usage_check()); // minimal output

pub fn show_estimates(&self) -> bool

Whether to show download time estimates.

PowerUser wants all metrics; Casual benefits from practical time estimates.

Example

use netspeed_cli::profiles::UserProfile;

assert!(UserProfile::PowerUser.show_estimates());
assert!(UserProfile::Casual.show_estimates());
assert!(!UserProfile::Gamer.show_estimates());
assert!(!UserProfile::Streamer.show_estimates());

pub fn show_history(&self) -> bool

Whether to show historical comparison.

PowerUser tracks trends; RemoteWorker monitors connection reliability over time.

Example

use netspeed_cli::profiles::UserProfile;

assert!(UserProfile::PowerUser.show_history());
assert!(UserProfile::RemoteWorker.show_history());
assert!(!UserProfile::Gamer.show_history());
assert!(!UserProfile::Casual.show_history());

pub fn show_ul_dl_ratio(&self) -> bool

Whether to show UL/DL ratio.

PowerUser wants all metrics; RemoteWorker cares about upload relative to download.

Example

use netspeed_cli::profiles::UserProfile;

assert!(UserProfile::PowerUser.show_ul_dl_ratio());
assert!(UserProfile::RemoteWorker.show_ul_dl_ratio());
assert!(!UserProfile::Streamer.show_ul_dl_ratio());
assert!(!UserProfile::Casual.show_ul_dl_ratio());

pub fn show_peaks(&self) -> bool

Whether to show peak speeds.

All profiles except Casual show peak speeds.

Example

use netspeed_cli::profiles::UserProfile;

assert!(UserProfile::PowerUser.show_peaks());
assert!(UserProfile::Gamer.show_peaks());
assert!(!UserProfile::Casual.show_peaks()); // minimal output

pub fn show_latency_under_load(&self) -> bool

Whether to show latency under load.

PowerUser wants all metrics; Gamer needs to know if loaded latency spikes.

Example

use netspeed_cli::profiles::UserProfile;

assert!(UserProfile::PowerUser.show_latency_under_load());
assert!(UserProfile::Gamer.show_latency_under_load());
assert!(!UserProfile::Streamer.show_latency_under_load());
assert!(!UserProfile::Casual.show_latency_under_load());

Trait Implementations

impl Clone for UserProfile

fn clone(&self) -> UserProfile

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UserProfile

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for UserProfile

fn default() -> UserProfile

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for UserProfile

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for UserProfile

fn eq(&self, other: &UserProfile) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for UserProfile

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for UserProfile

impl Eq for UserProfile

impl StructuralPartialEq for UserProfile