lemon_bugsnag_rs 0.1.2

use serde::Serialize;

use super::{enums::SeverityReasonType, SeverityReasonAttribute};

/// Struct corresponding to the `events -> severity_reason` key in the BugSnag
/// error-reporting API payload. Contains information about why a specific
/// severity is selected.
///
/// ```
/// use lemon_bugsnag_rs::error::payload::events::SeverityReason;
///
/// let severity_reason = SeverityReason::default();
/// ```
#[derive(Clone, Debug, Default, Serialize, Eq, PartialEq)]
#[serde(rename_all = "camelCase")]
pub struct SeverityReason {
    /// The type of severity
    #[serde(rename(serialize = "type"))]
    pub severity_reason_type: Option<SeverityReasonType>,
    /// Optional attributes providing additional information about the severity
    pub attributes: Option<SeverityReasonAttribute>,
    /// Whether the unhandled flag was overriden from the notifier's deafult
    /// value
    pub unhandled_overridden: Option<bool>,
}

#[cfg_attr(docsrs, doc(cfg(feature = "optional-builders")))]
#[cfg(feature = "optional-builders")]
impl SeverityReason {
    /// Retrieve a [SeverityReasonBuilder].
    ///
    /// ```
    /// use lemon_bugsnag_rs::error::payload::events::SeverityReason;
    ///
    /// let mut sb = SeverityReason::builder();
    /// ```
    pub fn builder() -> SeverityReasonBuilder {
        SeverityReasonBuilder {
            severity_reason: SeverityReason {
                severity_reason_type: None,
                attributes: None,
                unhandled_overridden: None,
            },
        }
    }
}

/// Builder used to generate a [SeverityReason] struct.
///
/// ```
/// use lemon_bugsnag_rs::error::payload::events::SeverityReason;
///
/// // Generally, you get the builder this way, rather than creating an
/// // ExceptionBuilder struct manually.
/// let mut sb = SeverityReason::builder();
/// ```
#[cfg_attr(docsrs, doc(cfg(feature = "optional-builders")))]
#[cfg(feature = "optional-builders")]
pub struct SeverityReasonBuilder {
    /// The severity reason
    severity_reason: SeverityReason,
}

#[cfg_attr(docsrs, doc(cfg(feature = "optional-builders")))]
#[cfg(feature = "optional-builders")]
impl SeverityReasonBuilder {
    /// Set the severity_reason_type field of the SeverityReason struct.
    ///
    /// ```
    /// use lemon_bugsnag_rs::error::payload::events::{
    ///     SeverityReason,
    ///     enums::SeverityReasonType
    /// };
    ///
    /// let mut sb = SeverityReason::builder();
    ///
    /// // Give the severity_reason_type a value.
    /// sb.set_severity_reason_type(SeverityReasonType::UnhandledException);
    ///
    /// // Unset the severity_reason_type.
    /// sb.set_severity_reason_type(None);
    /// ```
    pub fn set_severity_reason_type(
        &mut self,
        severity_reason_type: impl Into<Option<SeverityReasonType>>,
    ) -> &mut Self {
        self.severity_reason.severity_reason_type = severity_reason_type.into();

        self
    }

    /// Set the attributes field of the SeverityReason struct.
    ///
    /// ```
    /// use lemon_bugsnag_rs::error::payload::events::{
    ///     SeverityReason,
    ///     SeverityReasonAttribute
    /// };
    ///
    /// let mut sb = SeverityReason::builder();
    /// let sba = SeverityReasonAttribute::builder().build();
    ///
    /// // Give the attributes a value.
    /// sb.set_attributes(sba);
    ///
    /// // Unset the attributes.
    /// sb.set_attributes(None);
    /// ```
    pub fn set_attributes(
        &mut self,
        attributes: impl Into<Option<SeverityReasonAttribute>>,
    ) -> &mut Self {
        self.severity_reason.attributes = attributes.into();

        self
    }

    /// Set the unhandled_overridden field of the SeverityReason struct.
    ///
    /// ```
    /// use lemon_bugsnag_rs::error::payload::events::{
    ///     SeverityReason
    /// };
    ///
    /// let mut sb = SeverityReason::builder();
    ///
    /// // Give the unhandled_overridden a value.
    /// sb.set_unhandled_overridden(false);
    ///
    /// // Unset the unhandled_overridden.
    /// sb.set_unhandled_overridden(None);
    /// ```
    pub fn set_unhandled_overridden(
        &mut self,
        unhandled_overridden: impl Into<Option<bool>>,
    ) -> &mut Self {
        self.severity_reason.unhandled_overridden = unhandled_overridden.into();

        self
    }

    /// Generate an [SeverityReason] struct using the options you set using the
    /// builder.
    ///
    /// ```
    /// use lemon_bugsnag_rs::error::payload::events::{
    ///     SeverityReason,
    ///     SeverityReasonAttribute,
    ///     enums::SeverityReasonType
    /// };
    ///
    /// let mut sb = SeverityReason::builder();
    /// let sba = SeverityReasonAttribute::builder().build();
    ///
    /// sb.set_severity_reason_type(SeverityReasonType::UnhandledException)
    ///     .set_attributes(sba)
    ///     .set_unhandled_overridden(false);
    ///
    /// let severity_reason = sb.build();
    /// ```
    pub fn build(&self) -> SeverityReason {
        self.severity_reason.clone()
    }
}

#[cfg(test)]
mod test {
    #[cfg(feature = "optional-builders")]
    #[test]
    pub fn test_error_payload_events_severity_reason_builder() {
        use crate::error::payload::events::enums::SeverityReasonType;
        use crate::error::payload::events::SeverityReason;
        use crate::error::payload::events::SeverityReasonAttribute;

        let severity_reason_attribute = SeverityReasonAttribute {
            error_class: "Car".to_string().into(),
            error_type: "Sparkplug".to_string().into(),
            exception_class: "Engine".to_string().into(),
            framework: "Unibody".to_string().into(),
            level: "Coupe".to_string().into(),
            signal_type: "Left".to_string().into(),
            violation_type: "Moving".to_string().into(),
        };

        let mut severity_reason_builder = SeverityReason::builder();
        let test_severity_reason = SeverityReason {
            severity_reason_type: SeverityReasonType::AppHang.into(),
            attributes: severity_reason_attribute.clone().into(),
            unhandled_overridden: true.into(),
        };

        let severity_reason = severity_reason_builder
            .set_severity_reason_type(
                test_severity_reason.severity_reason_type.clone(),
            )
            .set_attributes(test_severity_reason.attributes.clone())
            .set_unhandled_overridden(
                test_severity_reason.unhandled_overridden.clone(),
            )
            .build();

        assert_eq!(severity_reason, test_severity_reason);
    }
}