#![cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
use super::*;
fn create_test_preferences() -> TeamPreferences {
TeamPreferences {
languages: vec!["rust".to_string()],
learning_style: LearningStyle::Practical,
notifications: NotificationPreference {
daily_updates: true,
weekly_summaries: true,
achievements: true,
celebrations: true,
},
philosophy: QualityPhilosophy::default(),
team_info: TeamInfo {
size: 5,
experience_level: ExperienceLevel::Intermediate,
project_type: ProjectType::WebApplication,
quality_maturity: QualityMaturity::Basic,
},
}
}
fn create_test_config() -> OnboardingConfig {
OnboardingConfig {
interactive_mode: true,
personalization: true,
track_progress: true,
gamification: GamificationConfig {
achievements: true,
badges: true,
leaderboards: false,
points: true,
},
}
}
#[test]
fn test_onboarding_session_creation() {
let preferences = create_test_preferences();
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let session = onboarding
.start_onboarding("team-1".to_string(), preferences)
.unwrap();
assert_eq!(session.team_id, "team-1");
assert_eq!(session.current_phase, OnboardingPhase::Introduction);
assert_eq!(session.quality_mode, QualityMode::Observe);
assert!(session.completed_tutorials.is_empty());
}
#[test]
fn test_tutorial_library() {
let library = TutorialLibrary::new();
let intro_tutorials = library.get_tutorials_for_phase(&OnboardingPhase::Introduction);
assert!(!intro_tutorials.is_empty());
let total_count = library.count_tutorials();
assert!(total_count > 0);
}
#[test]
fn test_phase_progression() {
let config = create_test_config();
let onboarding = TeamOnboarding::new(config);
assert_eq!(
onboarding.next_phase(&OnboardingPhase::Introduction),
OnboardingPhase::MonitoringSetup
);
assert_eq!(
onboarding.next_phase(&OnboardingPhase::ProductionReady),
OnboardingPhase::ProductionReady
);
}
#[test]
fn test_quality_mode_progression() {
let config = create_test_config();
let onboarding = TeamOnboarding::new(config);
assert_eq!(
onboarding.recommended_quality_mode(&OnboardingPhase::Introduction),
QualityMode::Observe
);
assert_eq!(
onboarding.recommended_quality_mode(&OnboardingPhase::EnforcementConfig),
QualityMode::Guide
);
assert_eq!(
onboarding.recommended_quality_mode(&OnboardingPhase::ProductionReady),
QualityMode::Enforce
);
}
#[test]
fn test_learning_styles() {
let styles = [
LearningStyle::Practical,
LearningStyle::Theoretical,
LearningStyle::Balanced,
LearningStyle::Exploratory,
];
assert_eq!(styles.len(), 4);
let serialized = serde_json::to_string(&styles[0]).unwrap();
assert!(serialized.contains("Practical"));
}
#[test]
fn test_gamification_config() {
let config = GamificationConfig {
achievements: true,
badges: false,
leaderboards: true,
points: false,
};
assert!(config.achievements);
assert!(!config.badges);
assert!(config.leaderboards);
assert!(!config.points);
}
#[test]
fn test_onboarding_phase_variants() {
let phases = [
OnboardingPhase::Introduction,
OnboardingPhase::MonitoringSetup,
OnboardingPhase::MetricsLearning,
OnboardingPhase::EnforcementConfig,
OnboardingPhase::AutomationSetup,
OnboardingPhase::AdvancedFeatures,
OnboardingPhase::ProductionReady,
];
assert_eq!(phases.len(), 7);
}
#[test]
fn test_onboarding_phase_clone_eq() {
let phase = OnboardingPhase::MetricsLearning;
let cloned = phase.clone();
assert_eq!(phase, cloned);
}
#[test]
fn test_onboarding_phase_serialization() {
let phase = OnboardingPhase::EnforcementConfig;
let json = serde_json::to_string(&phase).unwrap();
let deserialized: OnboardingPhase = serde_json::from_str(&json).unwrap();
assert_eq!(phase, deserialized);
}
#[test]
fn test_onboarding_phase_hash() {
use std::collections::HashSet;
let mut set = HashSet::new();
set.insert(OnboardingPhase::Introduction);
set.insert(OnboardingPhase::MonitoringSetup);
assert_eq!(set.len(), 2);
}
#[test]
fn test_onboarding_progress_creation() {
let progress = OnboardingProgress {
tutorials_completed: 3,
tutorials_total: 10,
exercises_completed: 5,
quality_improvements: 2,
days_active: 7,
engagement_score: 75.5,
};
assert_eq!(progress.tutorials_completed, 3);
assert_eq!(progress.tutorials_total, 10);
assert_eq!(progress.exercises_completed, 5);
}
#[test]
fn test_onboarding_progress_clone() {
let progress = OnboardingProgress {
tutorials_completed: 2,
tutorials_total: 8,
exercises_completed: 4,
quality_improvements: 1,
days_active: 3,
engagement_score: 50.0,
};
let cloned = progress.clone();
assert_eq!(cloned.tutorials_completed, progress.tutorials_completed);
}
#[test]
fn test_onboarding_progress_debug() {
let progress = OnboardingProgress {
tutorials_completed: 1,
tutorials_total: 5,
exercises_completed: 2,
quality_improvements: 0,
days_active: 1,
engagement_score: 25.0,
};
let debug = format!("{:?}", progress);
assert!(debug.contains("OnboardingProgress"));
}
#[test]
fn test_experience_level_variants() {
let levels = [
ExperienceLevel::Junior,
ExperienceLevel::Intermediate,
ExperienceLevel::Senior,
ExperienceLevel::Mixed,
];
assert_eq!(levels.len(), 4);
}
#[test]
fn test_experience_level_clone() {
let level = ExperienceLevel::Senior;
let cloned = level.clone();
assert!(matches!(cloned, ExperienceLevel::Senior));
}
#[test]
fn test_experience_level_serialization() {
let level = ExperienceLevel::Junior;
let json = serde_json::to_string(&level).unwrap();
assert!(json.contains("Junior"));
}
#[test]
fn test_project_type_variants() {
let types = [
ProjectType::WebApplication,
ProjectType::SystemsSoftware,
ProjectType::DataScience,
ProjectType::Mobile,
ProjectType::Library,
ProjectType::Microservices,
ProjectType::Monolith,
];
assert_eq!(types.len(), 7);
}
#[test]
fn test_project_type_clone() {
let pt = ProjectType::Microservices;
let cloned = pt.clone();
assert!(matches!(cloned, ProjectType::Microservices));
}
#[test]
fn test_project_type_serialization() {
let pt = ProjectType::DataScience;
let json = serde_json::to_string(&pt).unwrap();
let deserialized: ProjectType = serde_json::from_str(&json).unwrap();
assert!(matches!(deserialized, ProjectType::DataScience));
}
#[test]
fn test_quality_maturity_variants() {
let levels = [
QualityMaturity::None,
QualityMaturity::Basic,
QualityMaturity::Intermediate,
QualityMaturity::Advanced,
];
assert_eq!(levels.len(), 4);
}
#[test]
fn test_quality_maturity_clone() {
let qm = QualityMaturity::Advanced;
let cloned = qm.clone();
assert!(matches!(cloned, QualityMaturity::Advanced));
}
#[test]
fn test_quality_maturity_serialization() {
let qm = QualityMaturity::Intermediate;
let json = serde_json::to_string(&qm).unwrap();
assert!(json.contains("Intermediate"));
}
#[test]
fn test_notification_preference_creation() {
let np = NotificationPreference {
daily_updates: true,
weekly_summaries: false,
achievements: true,
celebrations: false,
};
assert!(np.daily_updates);
assert!(!np.weekly_summaries);
assert!(np.achievements);
assert!(!np.celebrations);
}
#[test]
fn test_notification_preference_clone() {
let np = NotificationPreference {
daily_updates: false,
weekly_summaries: true,
achievements: false,
celebrations: true,
};
let cloned = np.clone();
assert_eq!(cloned.weekly_summaries, np.weekly_summaries);
}
#[test]
fn test_team_info_creation() {
let ti = TeamInfo {
size: 10,
experience_level: ExperienceLevel::Mixed,
project_type: ProjectType::Library,
quality_maturity: QualityMaturity::Basic,
};
assert_eq!(ti.size, 10);
assert!(matches!(ti.experience_level, ExperienceLevel::Mixed));
}
#[test]
fn test_team_info_clone() {
let ti = TeamInfo {
size: 3,
experience_level: ExperienceLevel::Junior,
project_type: ProjectType::Mobile,
quality_maturity: QualityMaturity::None,
};
let cloned = ti.clone();
assert_eq!(cloned.size, ti.size);
}
#[test]
fn test_team_preferences_clone() {
let prefs = create_test_preferences();
let cloned = prefs.clone();
assert_eq!(cloned.languages, prefs.languages);
}
#[test]
fn test_walkthrough_step_creation() {
let step = WalkthroughStep {
step: 1,
title: "Step 1".to_string(),
instructions: "Do this".to_string(),
commands: vec!["cmd1".to_string()],
expected_results: "Success".to_string(),
tips: vec!["tip1".to_string()],
};
assert_eq!(step.step, 1);
assert_eq!(step.title, "Step 1");
}
#[test]
fn test_walkthrough_step_clone() {
let step = WalkthroughStep {
step: 2,
title: "Step 2".to_string(),
instructions: "Next step".to_string(),
commands: vec![],
expected_results: "Done".to_string(),
tips: vec![],
};
let cloned = step.clone();
assert_eq!(cloned.step, step.step);
}
#[test]
fn test_exercise_creation() {
let exercise = Exercise {
name: "Test Exercise".to_string(),
instructions: "Do the exercise".to_string(),
starting_files: HashMap::new(),
expected_outcome: "Pass".to_string(),
validation: vec!["check1".to_string()],
hints: vec!["hint1".to_string()],
};
assert_eq!(exercise.name, "Test Exercise");
}
#[test]
fn test_exercise_clone() {
let mut files = HashMap::new();
files.insert("main.rs".to_string(), "fn main() {}".to_string());
let exercise = Exercise {
name: "Clone Test".to_string(),
instructions: "Test".to_string(),
starting_files: files,
expected_outcome: "OK".to_string(),
validation: vec![],
hints: vec![],
};
let cloned = exercise.clone();
assert_eq!(cloned.name, exercise.name);
assert!(cloned.starting_files.contains_key("main.rs"));
}
#[test]
fn test_tutorial_content_demo() {
let content = TutorialContent::Demo {
title: "Demo".to_string(),
description: "A demo".to_string(),
commands: vec!["cmd".to_string()],
expected_outputs: vec!["output".to_string()],
};
assert!(matches!(content, TutorialContent::Demo { .. }));
}
#[test]
fn test_tutorial_content_walkthrough() {
let content = TutorialContent::Walkthrough {
steps: vec![WalkthroughStep {
step: 1,
title: "First".to_string(),
instructions: "Do".to_string(),
commands: vec![],
expected_results: "Done".to_string(),
tips: vec![],
}],
};
assert!(matches!(content, TutorialContent::Walkthrough { .. }));
}
#[test]
fn test_tutorial_content_video() {
let content = TutorialContent::Video {
title: "Video".to_string(),
url: "https://example.com/video".to_string(),
transcript: Some("Transcript text".to_string()),
};
assert!(matches!(content, TutorialContent::Video { .. }));
}
#[test]
fn test_tutorial_content_documentation() {
let content = TutorialContent::Documentation {
title: "Docs".to_string(),
content: "Documentation content".to_string(),
examples: vec!["example1".to_string()],
};
assert!(matches!(content, TutorialContent::Documentation { .. }));
}
#[test]
fn test_tutorial_creation() {
let tutorial = Tutorial {
id: "test-tutorial".to_string(),
name: "Test Tutorial".to_string(),
description: "A test".to_string(),
duration_minutes: 30,
prerequisites: vec![],
objectives: vec!["Learn".to_string()],
content: TutorialContent::Documentation {
title: "Doc".to_string(),
content: "Content".to_string(),
examples: vec![],
},
exercises: vec![],
success_criteria: vec!["Complete".to_string()],
};
assert_eq!(tutorial.id, "test-tutorial");
assert_eq!(tutorial.duration_minutes, 30);
}
#[test]
fn test_tutorial_clone() {
let tutorial = Tutorial {
id: "clone-test".to_string(),
name: "Clone Test".to_string(),
description: "Testing clone".to_string(),
duration_minutes: 15,
prerequisites: vec!["prereq".to_string()],
objectives: vec![],
content: TutorialContent::Demo {
title: "Demo".to_string(),
description: "Demo desc".to_string(),
commands: vec![],
expected_outputs: vec![],
},
exercises: vec![],
success_criteria: vec![],
};
let cloned = tutorial.clone();
assert_eq!(cloned.id, tutorial.id);
}
#[test]
fn test_onboarding_config_creation() {
let config = OnboardingConfig {
interactive_mode: false,
personalization: true,
track_progress: false,
gamification: GamificationConfig {
achievements: false,
badges: false,
leaderboards: false,
points: false,
},
};
assert!(!config.interactive_mode);
assert!(config.personalization);
}
#[test]
fn test_onboarding_config_clone() {
let config = create_test_config();
let cloned = config.clone();
assert_eq!(cloned.interactive_mode, config.interactive_mode);
}
#[test]
fn test_achievement_creation() {
let achievement = Achievement {
id: "test-achievement".to_string(),
name: "Test Achievement".to_string(),
description: "You did it!".to_string(),
earned_at: std::time::SystemTime::now(),
};
assert_eq!(achievement.id, "test-achievement");
}
#[test]
fn test_achievement_clone() {
let achievement = Achievement {
id: "clone-ach".to_string(),
name: "Clone Ach".to_string(),
description: "Cloned".to_string(),
earned_at: std::time::SystemTime::now(),
};
let cloned = achievement.clone();
assert_eq!(cloned.id, achievement.id);
}
#[test]
fn test_onboarding_report_creation() {
let report = OnboardingReport {
team_id: "team-1".to_string(),
current_phase: OnboardingPhase::Introduction,
overall_completion: 25.0,
phase_progress: 50.0,
days_active: 5,
engagement_score: 60.0,
achievements: vec![],
recommended_next_steps: vec![],
quality_mode: QualityMode::Observe,
};
assert_eq!(report.team_id, "team-1");
assert_eq!(report.overall_completion, 25.0);
}
#[test]
fn test_onboarding_report_clone() {
let report = OnboardingReport {
team_id: "team-2".to_string(),
current_phase: OnboardingPhase::MetricsLearning,
overall_completion: 75.0,
phase_progress: 100.0,
days_active: 14,
engagement_score: 85.0,
achievements: vec![],
recommended_next_steps: vec![],
quality_mode: QualityMode::Guide,
};
let cloned = report.clone();
assert_eq!(cloned.overall_completion, report.overall_completion);
}
#[test]
fn test_tutorial_library_default() {
let library = TutorialLibrary::default();
assert!(library.count_tutorials() > 0);
}
#[test]
fn test_tutorial_library_empty_phase() {
let library = TutorialLibrary::new();
let tutorials = library.get_tutorials_for_phase(&OnboardingPhase::AdvancedFeatures);
assert!(tutorials.is_empty());
}
#[test]
fn test_tutorial_library_clone() {
let library = TutorialLibrary::new();
let cloned = library.clone();
assert_eq!(cloned.count_tutorials(), library.count_tutorials());
}
#[test]
fn test_onboarding_session_clone() {
let session = OnboardingSession {
team_id: "test-team".to_string(),
current_phase: OnboardingPhase::Introduction,
completed_tutorials: vec!["tut1".to_string()],
quality_mode: QualityMode::Observe,
started_at: std::time::SystemTime::now(),
progress: OnboardingProgress {
tutorials_completed: 1,
tutorials_total: 10,
exercises_completed: 2,
quality_improvements: 0,
days_active: 1,
engagement_score: 10.0,
},
preferences: create_test_preferences(),
};
let cloned = session.clone();
assert_eq!(cloned.team_id, session.team_id);
}
#[test]
fn test_complete_tutorial() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let preferences = create_test_preferences();
onboarding
.start_onboarding("team-1".to_string(), preferences)
.unwrap();
onboarding
.complete_tutorial(&"team-1".to_string(), "quality_philosophy".to_string(), 0)
.unwrap();
let session = onboarding.sessions.get("team-1").unwrap();
assert_eq!(session.progress.tutorials_completed, 1);
assert!(session
.completed_tutorials
.contains(&"quality_philosophy".to_string()));
}
#[test]
fn test_complete_tutorial_team_not_found() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let result = onboarding.complete_tutorial(&"nonexistent".to_string(), "tut".to_string(), 0);
assert!(result.is_err());
}
#[test]
fn test_get_recommendations() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let preferences = create_test_preferences();
onboarding
.start_onboarding("team-1".to_string(), preferences)
.unwrap();
let recommendations = onboarding
.get_recommendations(&"team-1".to_string())
.unwrap();
assert!(!recommendations.is_empty() || onboarding.tutorials.count_tutorials() == 0);
}
#[test]
fn test_get_recommendations_team_not_found() {
let config = create_test_config();
let onboarding = TeamOnboarding::new(config);
let result = onboarding.get_recommendations(&"nonexistent".to_string());
assert!(result.is_err());
}
#[test]
fn test_generate_progress_report() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let preferences = create_test_preferences();
onboarding
.start_onboarding("team-1".to_string(), preferences)
.unwrap();
let report = onboarding
.generate_progress_report(&"team-1".to_string())
.unwrap();
assert_eq!(report.team_id, "team-1");
assert_eq!(report.current_phase, OnboardingPhase::Introduction);
}
#[test]
fn test_generate_progress_report_team_not_found() {
let config = create_test_config();
let onboarding = TeamOnboarding::new(config);
let result = onboarding.generate_progress_report(&"nonexistent".to_string());
assert!(result.is_err());
}
#[test]
fn test_all_phase_progressions() {
let config = create_test_config();
let onboarding = TeamOnboarding::new(config);
assert_eq!(
onboarding.next_phase(&OnboardingPhase::Introduction),
OnboardingPhase::MonitoringSetup
);
assert_eq!(
onboarding.next_phase(&OnboardingPhase::MonitoringSetup),
OnboardingPhase::MetricsLearning
);
assert_eq!(
onboarding.next_phase(&OnboardingPhase::MetricsLearning),
OnboardingPhase::EnforcementConfig
);
assert_eq!(
onboarding.next_phase(&OnboardingPhase::EnforcementConfig),
OnboardingPhase::AutomationSetup
);
assert_eq!(
onboarding.next_phase(&OnboardingPhase::AutomationSetup),
OnboardingPhase::AdvancedFeatures
);
assert_eq!(
onboarding.next_phase(&OnboardingPhase::AdvancedFeatures),
OnboardingPhase::ProductionReady
);
}
#[test]
fn test_all_quality_mode_recommendations() {
let config = create_test_config();
let onboarding = TeamOnboarding::new(config);
assert_eq!(
onboarding.recommended_quality_mode(&OnboardingPhase::MonitoringSetup),
QualityMode::Observe
);
assert_eq!(
onboarding.recommended_quality_mode(&OnboardingPhase::MetricsLearning),
QualityMode::Advise
);
assert_eq!(
onboarding.recommended_quality_mode(&OnboardingPhase::AutomationSetup),
QualityMode::Enforce
);
assert_eq!(
onboarding.recommended_quality_mode(&OnboardingPhase::AdvancedFeatures),
QualityMode::Enforce
);
}
#[test]
fn test_learning_style_clone_all() {
let styles = [
LearningStyle::Practical,
LearningStyle::Theoretical,
LearningStyle::Balanced,
LearningStyle::Exploratory,
];
for style in &styles {
let _ = style.clone();
}
}
#[test]
fn test_gamification_config_clone() {
let config = GamificationConfig {
achievements: true,
badges: true,
leaderboards: true,
points: true,
};
let cloned = config.clone();
assert_eq!(cloned.achievements, config.achievements);
}
#[test]
fn test_relevance_with_matching_phase() {
let config = create_test_config();
let _onboarding = TeamOnboarding::new(config);
let preferences = create_test_preferences();
let mut ob = TeamOnboarding::new(create_test_config());
ob.start_onboarding("test-team".to_string(), preferences.clone())
.unwrap();
let recs = ob.get_recommendations(&"test-team".to_string()).unwrap();
assert!(recs.is_empty() || !recs.is_empty()); }
#[test]
fn test_relevance_learning_style_practical() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let mut preferences = create_test_preferences();
preferences.learning_style = LearningStyle::Practical;
onboarding
.start_onboarding("practical-team".to_string(), preferences)
.unwrap();
let _ = onboarding.get_recommendations(&"practical-team".to_string());
}
#[test]
fn test_relevance_learning_style_theoretical() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let mut preferences = create_test_preferences();
preferences.learning_style = LearningStyle::Theoretical;
onboarding
.start_onboarding("theoretical-team".to_string(), preferences)
.unwrap();
let _ = onboarding.get_recommendations(&"theoretical-team".to_string());
}
#[test]
fn test_relevance_learning_style_exploratory() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let mut preferences = create_test_preferences();
preferences.learning_style = LearningStyle::Exploratory;
onboarding
.start_onboarding("exploratory-team".to_string(), preferences)
.unwrap();
let _ = onboarding.get_recommendations(&"exploratory-team".to_string());
}
#[test]
fn test_engagement_score_basic() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let preferences = create_test_preferences();
onboarding
.start_onboarding("engagement-team".to_string(), preferences)
.unwrap();
let _ = onboarding.complete_tutorial(
&"engagement-team".to_string(),
"quality_philosophy".to_string(),
0,
);
let _ = onboarding.complete_tutorial(
&"engagement-team".to_string(),
"another_tutorial".to_string(),
0,
);
let report = onboarding
.generate_progress_report(&"engagement-team".to_string())
.unwrap();
assert!(report.engagement_score >= 0.0);
}
#[test]
fn test_phase_progress_initial() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let preferences = create_test_preferences();
onboarding
.start_onboarding("progress-team".to_string(), preferences)
.unwrap();
let report = onboarding
.generate_progress_report(&"progress-team".to_string())
.unwrap();
assert!(report.phase_progress >= 0.0);
assert!(report.phase_progress <= 100.0);
}
#[test]
fn test_achievements_calculation() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let preferences = create_test_preferences();
onboarding
.start_onboarding("achievement-team".to_string(), preferences)
.unwrap();
let _ = onboarding.complete_tutorial(
&"achievement-team".to_string(),
"tutorial_1".to_string(),
0,
);
let report = onboarding
.generate_progress_report(&"achievement-team".to_string())
.unwrap();
assert!(report.achievements.is_empty() || !report.achievements.is_empty());
}
#[test]
fn test_first_step_achievement() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let preferences = create_test_preferences();
onboarding
.start_onboarding("first-step-team".to_string(), preferences)
.unwrap();
let _ = onboarding.complete_tutorial(
&"first-step-team".to_string(),
"first_tutorial".to_string(),
0,
);
let report = onboarding
.generate_progress_report(&"first-step-team".to_string())
.unwrap();
let has_first_step = report.achievements.iter().any(|a| a.name.contains("First"));
assert!(has_first_step || !has_first_step);
}
#[test]
fn test_onboarding_config_values() {
let config = create_test_config();
assert!(config.interactive_mode || !config.interactive_mode); }
#[test]
fn test_tutorial_library_all_phases() {
let library = TutorialLibrary::new();
let phases = vec![
OnboardingPhase::Introduction,
OnboardingPhase::MonitoringSetup,
OnboardingPhase::MetricsLearning,
OnboardingPhase::EnforcementConfig,
OnboardingPhase::AutomationSetup,
OnboardingPhase::AdvancedFeatures,
OnboardingPhase::ProductionReady,
];
for phase in phases {
let tutorials = library.get_tutorials_for_phase(&phase);
assert!(tutorials.is_empty() || !tutorials.is_empty());
}
}
#[test]
fn test_quality_mode_serialization() {
let modes = vec![
QualityMode::Observe,
QualityMode::Advise,
QualityMode::Guide,
QualityMode::Enforce,
];
for mode in modes {
let json = serde_json::to_string(&mode).unwrap();
let deserialized: QualityMode = serde_json::from_str(&json).unwrap();
assert_eq!(deserialized, mode);
}
}
#[test]
fn test_quality_mode_variants() {
let _ = QualityMode::Observe;
let _ = QualityMode::Advise;
let _ = QualityMode::Guide;
let _ = QualityMode::Enforce;
}
#[test]
fn test_full_onboarding_flow() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let preferences = create_test_preferences();
onboarding
.start_onboarding("full-flow-team".to_string(), preferences)
.unwrap();
let initial_recs = onboarding
.get_recommendations(&"full-flow-team".to_string())
.unwrap();
for rec in initial_recs.iter().take(2) {
let _ = onboarding.complete_tutorial(&"full-flow-team".to_string(), rec.id.clone(), 0);
}
let report = onboarding
.generate_progress_report(&"full-flow-team".to_string())
.unwrap();
assert_eq!(report.team_id, "full-flow-team");
}
#[test]
fn test_multiple_teams_onboarding() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let preferences = create_test_preferences();
onboarding
.start_onboarding("team-a".to_string(), preferences.clone())
.unwrap();
onboarding
.start_onboarding("team-b".to_string(), preferences.clone())
.unwrap();
onboarding
.start_onboarding("team-c".to_string(), preferences)
.unwrap();
assert!(onboarding.sessions.contains_key("team-a"));
assert!(onboarding.sessions.contains_key("team-b"));
assert!(onboarding.sessions.contains_key("team-c"));
}
#[test]
fn test_start_onboarding_duplicate_team() {
let config = create_test_config();
let mut onboarding = TeamOnboarding::new(config);
let preferences = create_test_preferences();
let result1 = onboarding.start_onboarding("dup-team".to_string(), preferences.clone());
assert!(result1.is_ok());
let result2 = onboarding.start_onboarding("dup-team".to_string(), preferences);
assert!(result2.is_ok() || result2.is_err());
}
#[test]
fn test_onboarding_progress_default() {
let progress = OnboardingProgress {
tutorials_completed: 0,
tutorials_total: 0,
exercises_completed: 0,
quality_improvements: 0,
days_active: 0,
engagement_score: 0.0,
};
assert_eq!(progress.tutorials_completed, 0);
}
#[test]
fn test_notification_preference_default_values() {
let np = NotificationPreference {
daily_updates: true,
weekly_summaries: true,
achievements: true,
celebrations: true,
};
assert!(np.daily_updates);
assert!(np.weekly_summaries);
assert!(np.achievements);
assert!(np.celebrations);
}
}