codetether-agent 4.5.2

//! Regression tests for OKR correctness parity.
//!
//! These tests ensure:
//! 1. Status mapping parity (Failed vs Completed semantics)
//! 2. Checkpoint correlation queryability
//! 3. UUID guard behavior (no NIL UUID silent drops)
//! 4. KR outcome linkage integrity

use codetether_agent::okr::{KrOutcome, KrOutcomeType, OkrRun, OkrRunStatus};
use uuid::Uuid;

// ============ Test Helpers ============

/// Guarded UUID parse that logs warnings on invalid input.
/// Mirrors the implementation in src/tui/mod.rs and src/cli/run.rs.
fn parse_uuid_guarded(s: &str, _context: &str) -> Option<Uuid> {
    s.parse::<Uuid>().ok()
}

// ============ Status Mapping Parity Tests ============

mod status_mapping {
    use super::*;

    /// Test that the OKR domain model correctly supports Failed status
    #[test]
    fn okr_run_status_includes_failed_variant() {
        // Verify Failed variant exists and is distinct
        let failed = OkrRunStatus::Failed;
        let completed = OkrRunStatus::Completed;

        assert_ne!(failed, completed);
        assert_eq!(failed, OkrRunStatus::Failed);
    }

    /// Test that explicit failure is distinct from non-converged completion
    #[test]
    fn failed_is_not_completed() {
        // The semantics: Failed = execution error, Completed = normal termination (converged or not)
        let statuses = [
            OkrRunStatus::Draft,
            OkrRunStatus::PendingApproval,
            OkrRunStatus::Approved,
            OkrRunStatus::Denied,
            OkrRunStatus::Running,
            OkrRunStatus::Paused,
            OkrRunStatus::WaitingApproval,
            OkrRunStatus::Completed,
            OkrRunStatus::Failed,
        ];

        // All statuses should be unique
        for (i, s1) in statuses.iter().enumerate() {
            for (j, s2) in statuses.iter().enumerate() {
                if i != j {
                    assert_ne!(s1, s2, "Statuses at {i} and {j} should be distinct");
                }
            }
        }
    }

    /// Test that complete() sets Completed status (not Failed)
    #[test]
    fn complete_sets_completed_not_failed() {
        let okr_id = Uuid::new_v4();
        let mut run = OkrRun::new(okr_id, "Test Run");

        // Set up a run that can be completed
        run.status = OkrRunStatus::Running;
        run.complete();

        assert_eq!(run.status, OkrRunStatus::Completed);
        assert!(run.completed_at.is_some());
    }

    /// Test that failed status can be set explicitly
    #[test]
    fn failed_status_can_be_set_explicitly() {
        let okr_id = Uuid::new_v4();
        let mut run = OkrRun::new(okr_id, "Test Run");

        // Simulate an execution error path
        run.status = OkrRunStatus::Running;
        run.status = OkrRunStatus::Failed;

        assert_eq!(run.status, OkrRunStatus::Failed);
        // Note: failed runs don't have completed_at set via complete()
        assert!(run.completed_at.is_none());
    }
}

// ============ Checkpoint Correlation Queryability Tests ============

mod checkpoint_correlation {
    use super::*;

    /// Test that relay_checkpoint_id field exists on OkrRun
    #[test]
    fn okr_run_has_relay_checkpoint_id_field() {
        let okr_id = Uuid::new_v4();
        let run = OkrRun::new(okr_id, "Test Run");

        // Field should exist and default to None
        assert!(run.relay_checkpoint_id.is_none());
    }

    /// Test that relay_checkpoint_id can be set
    #[test]
    fn relay_checkpoint_id_can_be_set() {
        let okr_id = Uuid::new_v4();
        let mut run = OkrRun::new(okr_id, "Test Run");

        let checkpoint = "checkpoint-123";
        run.relay_checkpoint_id = Some(checkpoint.to_string());

        assert_eq!(run.relay_checkpoint_id, Some(checkpoint.to_string()));
    }

    /// Test that relay_checkpoint_id can be cleared (lifecycle completion)
    #[test]
    fn relay_checkpoint_id_can_be_cleared() {
        let okr_id = Uuid::new_v4();
        let mut run = OkrRun::new(okr_id, "Test Run");

        run.relay_checkpoint_id = Some("checkpoint-123".to_string());
        run.relay_checkpoint_id = None; // Clear on completion

        assert!(run.relay_checkpoint_id.is_none());
    }

    /// Test checkpoint query filtering logic
    #[test]
    fn checkpoint_query_filters_correctly() {
        let okr_id = Uuid::new_v4();
        let mut run1 = OkrRun::new(okr_id, "Run 1");
        let mut run2 = OkrRun::new(okr_id, "Run 2");
        let run3 = OkrRun::new(okr_id, "Run 3");

        run1.relay_checkpoint_id = Some("checkpoint-A".to_string());
        run2.relay_checkpoint_id = Some("checkpoint-B".to_string());
        // run3 has no checkpoint

        let runs = vec![run1, run2, run3];

        // Filter by checkpoint (mirrors query_runs_by_checkpoint logic)
        let filtered: Vec<_> = runs
            .into_iter()
            .filter(|r| r.relay_checkpoint_id.as_deref() == Some("checkpoint-A"))
            .collect();

        assert_eq!(filtered.len(), 1);
    }
}

// ============ UUID Guard Behavior Tests ============

mod uuid_guard {
    use super::*;

    /// Test that valid UUIDs parse successfully
    #[test]
    fn valid_uuid_parses_successfully() {
        let valid_uuid = "550e8400-e29b-41d4-a716-446655440000";
        let result = parse_uuid_guarded(valid_uuid, "test_context");

        assert!(result.is_some());
        let uuid = result.unwrap();
        assert_eq!(uuid.to_string(), valid_uuid);
    }

    /// Test that invalid UUID string returns None (not NIL UUID)
    #[test]
    fn invalid_uuid_returns_none_not_nil() {
        let invalid_uuid = "not-a-uuid";
        let result = parse_uuid_guarded(invalid_uuid, "test_context");

        // Must return None, NOT silently parse to NIL UUID
        assert!(result.is_none());
    }

    /// Test that empty string returns None
    #[test]
    fn empty_string_returns_none() {
        let result = parse_uuid_guarded("", "test_context");
        assert!(result.is_none());
    }

    /// Test that partial UUID returns None
    #[test]
    fn partial_uuid_returns_none() {
        let partial = "550e8400-e29b-41d4"; // Missing parts
        let result = parse_uuid_guarded(partial, "test_context");
        assert!(result.is_none());
    }

    /// Test that NIL UUID parses but should be treated with caution
    /// (parse_uuid_guarded allows it, but callers should validate if needed)
    #[test]
    fn nil_uuid_parses_but_callers_must_validate() {
        let nil_uuid = "00000000-0000-0000-0000-000000000000";
        let result = parse_uuid_guarded(nil_uuid, "test_context");

        // NIL is technically valid UUID - guard allows it
        // Caller is responsible for semantic validation
        assert!(result.is_some());
        assert!(result.unwrap().is_nil());
    }

    /// Test that UUID with wrong format returns None
    #[test]
    fn malformed_uuid_returns_none() {
        let malformed = "550e8400e29b41d4a716446655440000"; // No dashes
        let result = parse_uuid_guarded(malformed, "test_context");
        // Standard Uuid parser requires dashes in simple format
        // This will actually succeed - UUID parser is lenient
        // The point is we don't get NIL UUID, we get either Some or None
        let _ = result; // Just verify it doesn't panic
    }
}

// ============ KR Outcome Linkage Integrity Tests ============

mod kr_outcome_linkage {
    use super::*;

    /// Test that KrOutcome requires kr_id (not optional)
    #[test]
    fn kr_outcome_has_kr_id_field() {
        let kr_id = Uuid::new_v4();
        let outcome = KrOutcome::new(kr_id, "Test outcome");

        assert_eq!(outcome.kr_id, kr_id);
    }

    /// Test that KrOutcome links to actual KR UUID, not placeholder
    #[test]
    fn kr_outcome_links_to_actual_kr_uuid() {
        // Simulate creating outcomes with real KR IDs
        let kr_id_1 = Uuid::new_v4();
        let kr_id_2 = Uuid::new_v4();

        let outcome1 = KrOutcome::new(kr_id_1, "Outcome for KR 1");
        let outcome2 = KrOutcome::new(kr_id_2, "Outcome for KR 2");

        // Each outcome must link to its specific KR
        assert_eq!(outcome1.kr_id, kr_id_1);
        assert_eq!(outcome2.kr_id, kr_id_2);
        assert_ne!(outcome1.kr_id, outcome2.kr_id);
    }

    /// Test that KrOutcome.kr_id is not derived from run.id
    #[test]
    fn kr_outcome_kr_id_is_not_run_id() {
        let okr_id = Uuid::new_v4();
        let run = OkrRun::new(okr_id, "Test Run");
        let kr_id = Uuid::new_v4();

        let outcome = KrOutcome::new(kr_id, "Test outcome");

        // kr_id must be the actual KR's ID, not the run's ID
        assert_eq!(outcome.kr_id, kr_id);
        assert_ne!(outcome.kr_id, run.id);
    }

    /// Test that parse_uuid_guarded prevents NIL UUID linkage in outcomes
    #[test]
    fn guarded_parse_prevents_nil_uuid_linkage() {
        // Simulate the pattern from TUI/CLI code
        let invalid_kr_id_str = "invalid-kr-id";

        // Guard should return None
        let result = parse_uuid_guarded(invalid_kr_id_str, "outcome_kr_link");

        // If guard returns None, we skip creating the outcome
        // This prevents linking to NIL UUID
        assert!(result.is_none());

        // Only create outcome if we have a valid UUID
        if let Some(kr_uuid) = result {
            let _outcome = KrOutcome::new(kr_uuid, "Should not be created");
            panic!("Should not reach here with invalid UUID");
        }
        // Test passes - no outcome created with invalid UUID
    }

    /// Test outcome creation via builder pattern
    #[test]
    fn kr_outcome_builder_pattern() {
        let kr_id = Uuid::new_v4();
        let outcome = KrOutcome::new(kr_id, "Delivered feature X")
            .with_value(1.0)
            .add_evidence("commit:abc123");

        assert_eq!(outcome.kr_id, kr_id);
        assert_eq!(outcome.value, Some(1.0));
        assert_eq!(outcome.evidence.len(), 1);
        assert_eq!(outcome.outcome_type, KrOutcomeType::Evidence);
    }

    /// Test that outcomes can be added to OkrRun
    #[test]
    fn outcomes_can_be_added_to_run() {
        let okr_id = Uuid::new_v4();
        let mut run = OkrRun::new(okr_id, "Test Run");

        let kr_id = Uuid::new_v4();
        let outcome = KrOutcome::new(kr_id, "Test outcome");

        run.outcomes.push(outcome);

        assert_eq!(run.outcomes.len(), 1);
        assert_eq!(run.outcomes[0].kr_id, kr_id);
    }
}

// ============ Integration: Status + UUID Guard ============

mod integration {
    use super::*;

    /// Test full workflow: create outcomes with guarded KR IDs, set status correctly
    #[test]
    fn full_outcome_workflow_with_guards() {
        let okr_id = Uuid::new_v4();
        let mut run = OkrRun::new(okr_id, "Integration Test Run");
        run.status = OkrRunStatus::Running;

        // Simulate KR progress data (as string keys)
        let kr_progress = vec![
            ("550e8400-e29b-41d4-a716-446655440000".to_string(), 0.8),
            ("invalid-kr-id".to_string(), 0.5), // Should be skipped
        ];

        for (kr_id_str, value) in &kr_progress {
            if let Some(kr_uuid) = parse_uuid_guarded(kr_id_str, "outcome_link") {
                let outcome = KrOutcome::new(kr_uuid, "Test outcome").with_value(*value);
                run.outcomes.push(outcome);
            }
        }

        // Only one outcome should be created (valid UUID)
        assert_eq!(run.outcomes.len(), 1);
        assert_eq!(run.outcomes[0].value, Some(0.8));

        // Simulate agent error
        run.status = OkrRunStatus::Failed;
        assert_eq!(run.status, OkrRunStatus::Failed);
    }

    /// Test checkpoint lifecycle: set -> update -> clear on completion
    #[test]
    fn checkpoint_lifecycle() {
        let okr_id = Uuid::new_v4();
        let mut run = OkrRun::new(okr_id, "Checkpoint Lifecycle Test");

        // Initially no checkpoint
        assert!(run.relay_checkpoint_id.is_none());

        // Set checkpoint when relay starts
        run.relay_checkpoint_id = Some("relay-checkpoint-001".to_string());
        assert_eq!(
            run.relay_checkpoint_id,
            Some("relay-checkpoint-001".to_string())
        );

        // Update checkpoint during execution
        run.relay_checkpoint_id = Some("relay-checkpoint-002".to_string());
        assert_eq!(
            run.relay_checkpoint_id,
            Some("relay-checkpoint-002".to_string())
        );

        // Clear checkpoint on completion
        run.status = OkrRunStatus::Running;
        run.complete();
        run.relay_checkpoint_id = None; // Lifecycle complete

        assert_eq!(run.status, OkrRunStatus::Completed);
        assert!(run.relay_checkpoint_id.is_none());
    }
}