cartulary 0.3.0-alpha.1

use super::identifier::CompanionIdentifier;
use super::kind::CompanionKind;

/// A companion observed on an issue: how it is addressed
/// ([`CompanionIdentifier`]) and what it is
/// ([`CompanionKind`]). Pure metadata — the loaded content is
/// fetched on demand via [`IssueRepository::read_companion`].
///
/// [`IssueRepository::read_companion`]:
/// crate::domain::usecases::issue::IssueRepository::read_companion
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct IssueCompanion {
    pub identifier: CompanionIdentifier,
    pub kind: CompanionKind,
}

impl IssueCompanion {
    pub fn new(identifier: CompanionIdentifier, kind: CompanionKind) -> Self {
        Self { identifier, kind }
    }
}

#[cfg(test)]
pub mod strategy {
    use super::super::identifier::strategy::companion_identifier;
    use super::super::kind::strategy::companion_kind;
    use super::IssueCompanion;
    use proptest::prelude::*;

    prop_compose! {
        pub fn issue_companion()(
            identifier in companion_identifier(),
            kind in companion_kind(),
        ) -> IssueCompanion {
            IssueCompanion::new(identifier, kind)
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use proptest::prelude::*;

    proptest! {
        #[test]
        fn round_trip_fields(c in strategy::issue_companion()) {
            prop_assert_eq!(IssueCompanion::new(c.identifier.clone(), c.kind), c);
        }
    }

    fn id(s: &str) -> CompanionIdentifier {
        CompanionIdentifier::new(s).unwrap()
    }

    #[test]
    fn carries_identifier_and_kind() {
        let c = IssueCompanion::new(id("plan.md"), CompanionKind::Plan);
        assert_eq!(c.identifier.as_str(), "plan.md");
        assert!(c.kind.is_managed());
    }

    #[test]
    fn other_variant_is_not_managed() {
        let c = IssueCompanion::new(id("mockup UX.xml"), CompanionKind::Other);
        assert_eq!(c.identifier.as_str(), "mockup UX.xml");
        assert!(!c.kind.is_managed());
    }
}