use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct Team {
pub id: crate::domain::id::Id,
pub name: String,
pub created_at: DateTime<Utc>,
pub updated_at: DateTime<Utc>,
}
impl Team {
pub fn new(id: crate::domain::id::Id, name: String) -> Self {
let now = Utc::now();
Self {
id,
name,
created_at: now,
updated_at: now,
}
}
pub fn with_timestamps(
id: crate::domain::id::Id,
name: String,
created_at: DateTime<Utc>,
updated_at: DateTime<Utc>,
) -> Self {
Self {
id,
name,
created_at,
updated_at,
}
}
pub fn validate_name(&self) -> Result<(), TeamError> {
if self.name.trim().is_empty() {
return Err(TeamError::InvalidName(
"Team name cannot be empty".to_string(),
));
}
if self.name.len() > 255 {
return Err(TeamError::InvalidName(
"Team name cannot exceed 255 characters".to_string(),
));
}
Ok(())
}
}
#[derive(Debug, thiserror::Error)]
pub enum TeamError {
#[error("Invalid team name: {0}")]
InvalidName(String),
#[error("Team not found: {0}")]
NotFound(crate::domain::id::Id),
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_team_new_sets_fields_and_timestamps() {
let id = crate::domain::id::Id::generate();
let before = Utc::now();
let team = Team::new(id, "My Team".to_string());
let after = Utc::now();
assert_eq!(team.id, id);
assert_eq!(team.name, "My Team");
assert!(team.created_at >= before && team.created_at <= after);
assert_eq!(team.created_at, team.updated_at);
}
#[test]
fn test_team_with_timestamps_sets_all_fields() {
let id = crate::domain::id::Id::generate();
let created = Utc::now();
let updated = created + chrono::Duration::seconds(10);
let team = Team::with_timestamps(id, "Test".to_string(), created, updated);
assert_eq!(team.id, id);
assert_eq!(team.name, "Test");
assert_eq!(team.created_at, created);
assert_eq!(team.updated_at, updated);
}
#[test]
fn test_validate_name_valid_passes() {
let team = Team::new(crate::domain::id::Id::generate(), "Valid Team".to_string());
assert!(team.validate_name().is_ok());
}
#[test]
fn test_validate_name_empty_fails() {
let team = Team::new(crate::domain::id::Id::generate(), String::new());
let err = team.validate_name().expect_err("empty name should fail");
match err {
TeamError::InvalidName(msg) => assert!(msg.contains("empty")),
other => panic!("expected InvalidName, got {:?}", other),
}
}
#[test]
fn test_validate_name_whitespace_only_fails() {
let team = Team::new(crate::domain::id::Id::generate(), " ".to_string());
assert!(team.validate_name().is_err());
}
#[test]
fn test_validate_name_too_long_fails() {
let long_name = "a".repeat(256);
let team = Team::new(crate::domain::id::Id::generate(), long_name);
let err = team.validate_name().expect_err("long name should fail");
match err {
TeamError::InvalidName(msg) => assert!(msg.contains("255")),
other => panic!("expected InvalidName, got {:?}", other),
}
}
#[test]
fn test_validate_name_max_length_passes() {
let max_name = "a".repeat(255);
let team = Team::new(crate::domain::id::Id::generate(), max_name);
assert!(team.validate_name().is_ok());
}
#[test]
fn test_team_clone_and_equality() {
let team = Team::new(crate::domain::id::Id::generate(), "Test".to_string());
let cloned = team.clone();
assert_eq!(team, cloned);
}
#[test]
fn test_team_serde_roundtrip() {
let team = Team::new(
crate::domain::id::Id::generate(),
"Serialize Team".to_string(),
);
let json = serde_json::to_string(&team).expect("serialize");
let deserialized: Team = serde_json::from_str(&json).expect("deserialize");
assert_eq!(team, deserialized);
}
#[test]
fn test_team_error_display() {
let invalid = TeamError::InvalidName("bad".to_string());
assert!(invalid.to_string().contains("Invalid team name"));
assert!(invalid.to_string().contains("bad"));
let not_found = TeamError::NotFound(crate::domain::id::Id::nil());
assert!(not_found.to_string().contains("Team not found"));
}
}