lemon_bugsnag_rs 0.1.2

use std::collections::HashMap;
use url::Url;

#[cfg_attr(docsrs, doc(cfg(feature = "error-client")))]
#[cfg(feature = "error-client")]
use crate::error::error_client_builder::ErrorClientBuilder;
#[cfg_attr(docsrs, doc(cfg(feature = "session-client")))]
#[cfg(feature = "session-client")]
use crate::session::session_client_builder::SessionClientBuilder;

use super::builder_options::BuilderOptions;
use crate::common::client::client_type::ClientType;

/// The top-level client builder, primarily used to stub out and return an
/// API-specific client builder. For example, [ClientBuilder::error()] and
/// [ClientBuilder::session()] to retrieve builders for the BugSnag error-reporting and
/// session APIs, respectively.
/// ```
/// // This example requires the error-client feature to be enabled.
/// // This example requires the session-client feature to be enabled.
/// // This example requires the sync feature to be enabled.
///
/// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
/// // Create an error builder.
/// let mut error_client_builder = ClientBuilder::error();
/// // Create a session builder.
/// let mut session_client_builder = ClientBuilder::session();
/// ```
#[derive(Debug)]
pub struct ClientBuilder;

impl ClientBuilder {
    /// Return a client builder for the BugSnag error-reporting API using sane
    /// defaults.
    ///
    /// # Example
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut error_client_builder = ClientBuilder::error();
    /// ```
    #[cfg_attr(docsrs, doc(cfg(feature = "error-client")))]
    #[cfg(feature = "error-client")]
    pub fn error() -> ErrorClientBuilder {
        ErrorClientBuilder {
            builder_internal: ClientBuilderInternal {
                options: BuilderOptions {
                    client_type: ClientType::Error,
                    scheme: None,
                    url: Some(
                        Url::parse("https://notify.bugsnag.com/").unwrap(),
                    ),
                    host: None,
                    port: None,
                    endpoint: None,
                    headers: Some(HashMap::new()),
                },
                api_key: None,
                payload_version: "5".into(),
                payload_version_override: None,
            },
            notifier: None,
            events: None,
        }
    }

    /// Return a client builder for the BugSnag sessions API using sane
    /// defaults.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut session_client_builder = ClientBuilder::session();
    /// ```
    #[cfg_attr(docsrs, doc(cfg(feature = "session-client")))]
    #[cfg(feature = "session-client")]
    pub fn session() -> SessionClientBuilder {
        SessionClientBuilder {
            builder_internal: ClientBuilderInternal {
                options: BuilderOptions {
                    client_type: ClientType::Session,
                    scheme: None,
                    url: Some(
                        Url::parse("https://sessions.bugsnag.com/").unwrap(),
                    ),
                    host: None,
                    port: None,
                    endpoint: None,
                    headers: Some(HashMap::new()),
                },
                api_key: None,
                payload_version: "1.0".into(),
                payload_version_override: None,
            },
            notifier: None,
            app: None,
            device: None,
            sessions: None,
            session_counts: None,
        }
    }
}

/// This builder allows the configuration of values that are common to all or
/// most of the BugSnag APIs we support. It will be shared among the
/// API-specific client builders.
///
/// The user of this library will not generally interact with this struct
/// directly. Rather, he or she will will use an API-specific builder which
/// in turn uses this struct.
///
/// [Deref](std::ops::Deref) can be implemented
/// on the API-specific structs to make configuration of the underlying
/// [ClientBuilderInternal] transparent to the caller. We have done so on
/// [ErrorClientBuilder] and [SessionClientBuilder].
///
/// # Example:
///
/// ```
/// /**
///  * Create an error client builder and do some basic configuration on it.
///  */
/// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
/// use lemon_bugsnag_rs::error::payload::notifier::Notifier;
///
/// // Create an ErrorClientBuilder with default configuration.
/// let mut builder = ClientBuilder::error();
///
/// // Call set_notifier(), which is specific to the error client builder,
/// // and therefore lives on the ErrorClientBuilder struct.
/// builder.set_notifier(Notifier::default());
///
/// // Call set_endpoint(), which is a common option used by all API targets in
/// // this library, and therefore lives on ClientBuilderInternal rather than
/// // any of the API-specific builder structs, such as
/// // ErrorClientBuilder and SessionClientBuilder.
/// builder.set_endpoint("/v2/error");
/// ```
#[derive(Clone, Debug, PartialEq)]
pub struct ClientBuilderInternal {
    pub(crate) options: BuilderOptions,
    pub(crate) api_key: Option<String>,
    pub(crate) payload_version: String,
    pub(crate) payload_version_override: Option<String>,
}

impl ClientBuilderInternal {
    /// Retrieve the API key, or None if one is not set.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let builder = ClientBuilder::error();
    /// match builder.api_key() {
    ///   Some(key) => {
    ///     // Do things
    ///   },
    ///   None => {
    ///     // Do other, possibly different, things.
    ///   }
    /// }
    /// ```
    pub fn api_key(&self) -> Option<String> {
        self.api_key.clone()
    }

    /// Set the API key to be used for calls to the BugSnag API.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut builder = ClientBuilder::error();
    /// // Same for Session
    /// // let mut builder = ClientBuilder::session();
    /// builder.set_api_key("fake api key");
    /// ```
    pub fn set_api_key<'a>(
        &mut self,
        key: impl Into<Option<&'a str>>,
    ) -> &mut Self {
        self.api_key = key.into().map(|s| s.to_string());

        self
    }

    /// Returns the client type. This is set immutably by ClientBuilder.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    /// use lemon_bugsnag_rs::common::client::client_type::ClientType;
    ///
    /// let mut builder = ClientBuilder::session();
    /// let client_type = builder.client_type();
    /// match client_type {
    ///     ClientType::Error => {
    ///         // Do Error Things
    ///     },
    ///     ClientType::Session => {
    ///         // Do Session Things
    ///     },
    ///     _ => {
    ///         // In the future, there may be other variants of ClientType
    ///     }
    /// }
    /// ```
    pub fn client_type(&self) -> ClientType {
        self.options.client_type
    }

    /// Returns the endpoint, or None if one is not set.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut builder = ClientBuilder::error();
    /// let endpoint = builder.endpoint().unwrap_or("/endpoint".to_string());
    /// ```
    pub fn endpoint(&self) -> Option<String> {
        self.options.endpoint.clone()
    }

    /// Sets the endpoint for API calls.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut builder = ClientBuilder::error();
    /// builder.set_endpoint("/endpoint");
    /// ```
    pub fn set_endpoint<'a>(
        &mut self,
        endpoint: impl Into<Option<&'a str>>,
    ) -> &mut Self {
        self.options.endpoint = endpoint.into().map(|s| s.to_string());

        self
    }

    /// Returns all headers. Returns None if none are set
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let builder = ClientBuilder::session();
    /// match builder.headers() {
    ///     Some(headers) => {
    ///         // Do things
    ///     },
    ///     None => {
    ///         // Do other, possibly different, things.
    ///     }
    /// }
    /// ```
    pub fn headers(&self) -> Option<HashMap<String, String>> {
        self.options.headers.clone()
    }

    /// Adds a single request header.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut builder = ClientBuilder::error();
    /// builder.add_header("Accept".to_string(), "application/json".to_string());
    /// builder
    ///     .add_header("Accept-Encoding".to_string(), "gzip, deflate, br".to_string())
    ///     .add_header("Connection".to_string(), "keep-alive".to_string());
    /// ```
    pub fn add_header(
        &mut self,
        header_name: impl Into<String>,
        header_value: impl Into<String>,
    ) -> &mut Self {
        // I prefer this to making the caller check and initialize
        // the headers map.
        if self.options.headers.is_none() {
            self.options.headers = Some(HashMap::new());
        }

        self.options
            .headers
            .as_mut()
            .unwrap()
            .insert(header_name.into(), header_value.into());

        self
    }

    /// Returns the host, or None if one is not set.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut builder = ClientBuilder::error();
    /// let host = builder.host();
    ///
    /// if host.is_some() {
    ///   // Do the things.
    /// } else {
    ///   // Complain to the manager.
    /// }
    /// ```
    pub fn host(&self) -> Option<String> {
        self.options.host.clone()
    }

    /// Sets the host for API calls.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut builder = ClientBuilder::error();
    /// builder.set_host("notify.bugsnag.com");
    /// ```
    pub fn set_host<'a>(
        &mut self,
        host: impl Into<Option<&'a str>>,
    ) -> &mut Self {
        self.options.host = host.into().map(|s| s.to_string());

        self
    }

    /// Returns the payload version, or None if one is not set.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut builder = ClientBuilder::error();
    /// let payload_version = builder.payload_version();
    /// ```
    pub fn payload_version(&self) -> String {
        if self.payload_version_override.is_some() {
            self.payload_version_override.clone().unwrap()
        } else {
            self.payload_version.clone()
        }
    }

    /// Set the payload version to be used for calls to the BugSnag API.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut builder = ClientBuilder::error();
    /// builder.set_payload_version("1.0");
    /// ```
    pub fn set_payload_version<'a>(
        &mut self,
        payload_version: impl Into<Option<&'a str>>,
    ) -> &mut Self {
        self.payload_version_override =
            payload_version.into().map(|s| s.to_string());

        self
    }

    /// Returns the port, or None if one is not set.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let builder = ClientBuilder::error();
    /// match builder.port() {
    ///   Some(port) => {
    ///     // Do things
    ///   },
    ///   None => {
    ///     // Do other, possibly different, things.
    ///   }
    /// }
    /// ```
    pub fn port(&self) -> Option<u16> {
        self.options.port
    }

    /// Set the port for the API endpoint.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut builder = ClientBuilder::session();
    /// builder.set_port(8800);
    /// ```
    pub fn set_port(&mut self, port: impl Into<Option<u16>>) -> &mut Self {
        self.options.port = port.into();

        self
    }

    /// Returns the URL scheme, or None if one is not set.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut builder = ClientBuilder::error();
    /// let maybe_scheme = builder.scheme();
    ///
    /// if maybe_scheme.is_none() {
    ///   // I dunno, maybe throw an error or something.
    /// } else {
    ///   let scheme = maybe_scheme.unwrap();
    ///   // Do things.
    /// }
    /// ```
    pub fn scheme(&self) -> Option<String> {
        self.options.scheme.clone()
    }

    /// Set the scheme for the API call.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let mut builder = ClientBuilder::session();
    /// builder.set_scheme("https");
    /// ```
    pub fn set_scheme<'a>(
        &mut self,
        scheme: impl Into<Option<&'a str>>,
    ) -> &mut Self {
        self.options.scheme = scheme.into().map(|s| s.to_string());

        self
    }

    /// Returns the URL, or None if one is not set.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    ///
    /// let builder = ClientBuilder::session();
    /// match builder.url() {
    ///   Some(url) => {
    ///     // Do things
    ///   },
    ///   None => {
    ///     // Do other, possibly different, things.
    ///   }
    /// }
    /// ```
    pub fn url(&self) -> Option<Url> {
        self.options.url.clone()
    }

    /// Set the URL to be used for calls to the BugSnag API.
    /// ```
    /// use lemon_bugsnag_rs::common::builder::client_builder::ClientBuilder;
    /// use url::Url;
    ///
    /// let mut builder = ClientBuilder::error();
    /// // In production code, you will want to gracefully handle the unwrap(),
    /// // which can panic.
    /// let url = Url::parse("https://example.com").unwrap();
    /// builder.set_url(url);
    /// ```
    pub fn set_url(&mut self, url: impl Into<Option<Url>>) -> &mut Self {
        self.options.url = url.into();

        self
    }
}

#[cfg(test)]
mod test {
    pub mod client_builder_internal_build {
        use crate::common::builder::client_builder::ClientBuilder;
        use crate::common::{
            builder::{
                builder_options::BuilderOptions,
                client_builder::ClientBuilderInternal,
            },
            client::client_type::ClientType,
        };
        use std::collections::HashMap;
        use url::Url;

        #[cfg(feature = "error-client")]
        use crate::error::error_client_builder::ErrorClientBuilder;

        #[cfg(feature = "session-client")]
        use crate::session::session_client_builder::SessionClientBuilder;

        #[test]
        #[cfg(feature = "error-client")]
        pub fn build_error_client_internal() {
            let builder = ClientBuilder::error();
            assert_eq!(
                builder,
                ErrorClientBuilder {
                    builder_internal: ClientBuilderInternal {
                        options: BuilderOptions {
                            client_type: ClientType::Error,
                            scheme: None,
                            url: Some(
                                Url::parse("https://notify.bugsnag.com/")
                                    .unwrap()
                            ),
                            host: None,
                            port: None,
                            endpoint: None,
                            headers: Some(HashMap::new()),
                        },
                        api_key: None,
                        payload_version: "5".into(),
                        payload_version_override: None,
                    },
                    notifier: None,
                    events: None,
                }
            )
        }

        #[cfg(feature = "session-client")]
        #[test]
        pub fn build_session_client_internal() {
            let builder = ClientBuilder::session();
            assert_eq!(
                builder,
                SessionClientBuilder {
                    builder_internal: ClientBuilderInternal {
                        options: BuilderOptions {
                            client_type: ClientType::Session,
                            scheme: None,
                            url: Some(
                                Url::parse("https://sessions.bugsnag.com/")
                                    .unwrap()
                            ),
                            host: None,
                            port: None,
                            endpoint: None,
                            headers: Some(HashMap::new()),
                        },
                        api_key: None,
                        payload_version: "1.0".into(),
                        payload_version_override: None,
                    },
                    notifier: None,
                    app: None,
                    device: None,
                    sessions: None,
                    session_counts: None,
                }
            )
        }
    }

    pub mod client_builder_setters {
        #[cfg(any(feature = "error-client", feature = "session-client"))]
        use super::super::{ClientBuilder, ClientBuilderInternal};
        #[cfg(any(feature = "error-client", feature = "session-client"))]
        use crate::common::{
            builder::builder_options::BuilderOptions,
            client::client_type::ClientType,
        };
        #[cfg(any(feature = "error-client", feature = "session-client"))]
        use std::collections::HashMap;
        #[cfg(any(feature = "error-client", feature = "session-client"))]
        use url::Url;

        #[cfg(feature = "error-client")]
        use crate::error::{
            error_client_builder::ErrorClientBuilder,
            payload::{
                events::{Event, Exception, StackTrace},
                notifier::Notifier,
            },
        };

        #[cfg(feature = "error-client")]
        #[test]
        pub fn error_client_builder() {
            let mut headers = HashMap::new();
            let header_name = "fake header name".to_string();
            let header_value = "fake header value".to_string();
            let payload_version_override = "0.2.4";
            headers.insert(header_name.clone(), header_value);

            let reference_error_builder = ErrorClientBuilder {
                builder_internal: ClientBuilderInternal {
                    options: BuilderOptions {
                        client_type: ClientType::Error,
                        scheme: Some("http".to_string()),
                        url: Some(Url::parse("https://google.com/").unwrap()),
                        host: Some("Fake Host".to_string()),
                        port: Some(4000),
                        endpoint: Some("https://google.com/".to_string()),
                        headers: Some(headers),
                    },
                    api_key: Some("FakeApiKey0123".to_string()),
                    payload_version: "5".to_string(),
                    payload_version_override: Some(
                        payload_version_override.to_string(),
                    ),
                },
                notifier: Some(Notifier {
                    name: "Fake Notifier".to_string(),
                    version: "0.0.1".to_string(),
                    url: "https://fake.com".to_string(),
                    dependencies: None,
                }),
                events: Some(
                    [Event {
                        app: None,
                        breadcrumbs: None,
                        context: None,
                        device: None,
                        exceptions: [Exception {
                            error_class: "Fake error class".to_string(),
                            message: None,
                            stack_trace: [StackTrace {
                                file: "Fake File".to_string(),
                                line_number: 10,
                                column_number: None,
                                method: "Fake Method".to_string(),
                                in_project: None,
                                code: None,
                                frame_address: None,
                                load_address: None,
                                is_lr: None,
                                is_pc: None,
                                symbol_address: None,
                                macho_file: None,
                                macho_load_address: None,
                                macho_uuid: None,
                                macho_vm_address: None,
                                code_identifier: None,
                            }]
                            .into(),
                            runtime_type: None,
                        }]
                        .into(),
                        feature_flags: None,
                        grouping_hash: None,
                        meta_data: None,
                        project_packages: None,
                        request: None,
                        session: None,
                        severity: None,
                        severity_reason: None,
                        threads: None,
                        unhandled: None,
                        user: None,
                    }]
                    .into(),
                ),
            };
            assert_ne!(
                reference_error_builder.payload_version,
                reference_error_builder
                    .payload_version_override
                    .clone()
                    .unwrap()
            );

            let mut test_error_builder = ClientBuilder::error();

            test_error_builder
                .set_api_key(
                    reference_error_builder.api_key().unwrap().as_str(),
                )
                .set_endpoint(
                    reference_error_builder.endpoint().unwrap().as_str(),
                )
                .add_header(
                    header_name.clone(),
                    reference_error_builder
                        .headers()
                        .unwrap()
                        .get(&header_name)
                        .unwrap(),
                )
                .set_host(reference_error_builder.host().unwrap().as_str())
                .set_payload_version(
                    reference_error_builder
                        .payload_version_override
                        .clone()
                        .unwrap()
                        .as_str(),
                )
                .set_port(reference_error_builder.port().unwrap())
                .set_scheme(reference_error_builder.scheme().unwrap().as_str())
                .set_url(reference_error_builder.url().unwrap());

            test_error_builder
                .set_notifier(
                    reference_error_builder.notifier().unwrap().clone(),
                )
                .set_events(reference_error_builder.events().clone());

            assert_eq!(test_error_builder, reference_error_builder)
        }

        #[cfg(feature = "session-client")]
        #[test]
        pub fn session_client_builder() {
            use crate::session::{
                payload::{
                    device::Device, notifier::Notifier as SessionNotifier,
                    session_counts::session_count::SessionCount,
                    sessions::Session, App,
                },
                session_client_builder::SessionClientBuilder,
            };
            use chrono::Timelike;

            let mut headers = HashMap::new();
            let header_name = "fake header name".to_string();
            let header_value = "fake header value".to_string();
            let payload_version_override = "0.2.4";
            headers.insert(header_name.clone(), header_value);

            let mut reference_session_builder = SessionClientBuilder {
                builder_internal: ClientBuilderInternal {
                    options: BuilderOptions {
                        client_type: ClientType::Session,
                        scheme: Some("https".to_string()),
                        url: Some(Url::parse("https://some.host/api").unwrap()),
                        host: Some("my.host".to_string()),
                        port: Some(128),
                        endpoint: Some("/endpoint".to_string()),
                        headers: Some(headers),
                    },
                    api_key: Some("FakeApiKey0123".to_string()),
                    payload_version: "1.0".to_string(),
                    payload_version_override: Some(
                        payload_version_override.to_string(),
                    ),
                },
                notifier: Some(SessionNotifier {
                    name: "Fake Name".to_string(),
                    version: "0.2.3".to_string(),
                    url: None,
                }),
                app: Some(App {
                    app_type: None,
                    release_stage: None,
                    version: None,
                    version_code: None,
                    bundle_version: None,
                    code_bundle_id: None,
                }),
                device: Some(Device {
                    hostname: None,
                    id: None,
                    manufacturer: None,
                    model: None,
                    model_number: None,
                    jailbroken: None,
                    os_name: None,
                    os_version: None,
                    user_agent: None,
                    runtime_versions: None,
                }),
                sessions: Some(vec![Session {
                    id: "1".to_string(),
                    started_at: chrono::Utc::now().with_minute(10).unwrap(),
                    user: None,
                }]),
                session_counts: Some((|| {
                    let time = chrono::Utc::now();
                    let mut session_counts = HashMap::new();
                    let session_count =
                        SessionCount { started_at: time, sessions_started: 2 };

                    session_counts.insert(time.to_string(), session_count);

                    session_counts
                })()),
            };

            assert_ne!(
                reference_session_builder.payload_version,
                reference_session_builder
                    .payload_version_override
                    .clone()
                    .unwrap()
            );

            let mut test_session_builder = ClientBuilder::session();

            test_session_builder
                .set_api_key(
                    reference_session_builder.api_key().unwrap().as_str(),
                )
                .set_endpoint(
                    reference_session_builder.endpoint().unwrap().as_str(),
                )
                .add_header(
                    header_name.clone(),
                    reference_session_builder
                        .headers()
                        .unwrap()
                        .get(&header_name)
                        .unwrap(),
                )
                .set_host(reference_session_builder.host().unwrap().as_str())
                .set_payload_version(
                    reference_session_builder
                        .payload_version_override
                        .clone()
                        .unwrap()
                        .as_str(),
                )
                .set_port(reference_session_builder.port().unwrap())
                .set_scheme(
                    reference_session_builder.scheme().unwrap().as_str(),
                )
                .set_url(reference_session_builder.url().unwrap());

            test_session_builder
                .set_notifier(
                    reference_session_builder.notifier().unwrap().clone(),
                )
                .set_app(reference_session_builder.app().unwrap().clone())
                .set_device(reference_session_builder.device().unwrap().clone())
                .set_sessions(
                    reference_session_builder.sessions().unwrap().clone(),
                )
                .set_session_counts(
                    reference_session_builder.session_counts().unwrap().clone(),
                );

            assert_eq!(reference_session_builder, test_session_builder);

            reference_session_builder.sessions = None;
            test_session_builder.set_sessions(None);

            let mut session_count = HashMap::new();
            session_count.insert(
                "01:23:34".to_string(),
                SessionCount {
                    started_at: chrono::Utc::now(),
                    sessions_started: 2,
                },
            );

            reference_session_builder.session_counts =
                Some(session_count.clone());
            test_session_builder.set_session_counts(session_count);
        }
    }
}