interprex-github 5.0.0

GitHub provider for all Interprex development-platform domains
Documentation
use interprex::{
    ProviderApp, ProviderAppId, ProviderError, Result, ReviewActor, ReviewActorId, ReviewActorKind,
};
use serde::Deserialize;

#[derive(Deserialize, PartialEq)]
pub(super) struct GithubUser {
    pub(super) node_id: String,
    pub(super) login: String,
    #[serde(rename = "type")]
    pub(super) kind: Option<String>,
}

#[derive(Deserialize, PartialEq)]
pub(super) struct GithubApp {
    pub(super) id: u64,
    slug: String,
    name: String,
}

pub(super) fn actor(id: String, login: String, kind: &str) -> Result<ReviewActor> {
    let kind = match kind {
        "User" => ReviewActorKind::User,
        "Bot" => ReviewActorKind::Bot,
        "Mannequin" => ReviewActorKind::Placeholder,
        "Organization" => ReviewActorKind::Organization,
        "EnterpriseUserAccount" => ReviewActorKind::EnterpriseUser,
        other => {
            return Err(ProviderError::Unrepresentable {
                provider: "github",
                fact: format!("unknown review actor kind {other}"),
            });
        }
    };
    Ok(ReviewActor {
        id: ReviewActorId::new(id).map_err(|error| ProviderError::Unrepresentable {
            provider: "github",
            fact: error.to_string(),
        })?,
        login,
        kind,
    })
}

pub(super) fn normalize_app(app: GithubApp) -> Result<ProviderApp> {
    Ok(ProviderApp {
        id: ProviderAppId::new(app.id.to_string()).map_err(|error| {
            ProviderError::Unrepresentable {
                provider: "github",
                fact: error.to_string(),
            }
        })?,
        slug: app.slug,
        name: app.name,
    })
}

pub(super) fn rest_actor(user: GithubUser) -> Result<ReviewActor> {
    let kind = user.kind.ok_or_else(|| ProviderError::Unrepresentable {
        provider: "github",
        fact: format!("actor {} has no type", user.login),
    })?;
    actor(user.node_id, user.login, &kind)
}

pub(super) fn ghost_actor(id: String) -> Result<ReviewActor> {
    Ok(ReviewActor {
        id: ReviewActorId::new(id).map_err(|error| ProviderError::Unrepresentable {
            provider: "github",
            fact: error.to_string(),
        })?,
        login: "ghost".to_owned(),
        kind: ReviewActorKind::Placeholder,
    })
}

#[cfg(test)]
mod tests {
    use interprex::ProviderError;

    use super::super::change_requests::{
        GithubPullRequest, GithubReview, normalize_change_request,
    };

    #[test]
    fn unknown_actor_kinds_are_unrepresentable() {
        let pull_request: GithubPullRequest =
            serde_json::from_str(include_str!("../../tests/fixtures/pull_request.json"))
                .expect("pull request fixture");
        let mut reviews: Vec<GithubReview> = serde_json::from_str(include_str!(
            "../../tests/fixtures/code_review_reviews.json"
        ))
        .expect("review fixture");
        reviews[0].user.as_mut().expect("reviewer").kind = Some("Repository".to_owned());

        let error = normalize_change_request(
            pull_request,
            reviews,
            Vec::new(),
            Vec::new(),
            Vec::new(),
            Vec::new(),
        )
        .expect_err("unknown actor kind must be unrepresentable");
        assert!(matches!(
            error,
            ProviderError::Unrepresentable { fact, .. } if fact.contains("unknown review actor kind")
        ));
    }
    #[test]
    fn actors_without_a_type_are_unrepresentable() {
        let pull_request: GithubPullRequest =
            serde_json::from_str(include_str!("../../tests/fixtures/pull_request.json"))
                .expect("pull request fixture");
        let mut reviews: Vec<GithubReview> = serde_json::from_str(include_str!(
            "../../tests/fixtures/code_review_reviews.json"
        ))
        .expect("review fixture");
        reviews[0].user.as_mut().expect("reviewer").kind = None;

        let error = normalize_change_request(
            pull_request,
            reviews,
            Vec::new(),
            Vec::new(),
            Vec::new(),
            Vec::new(),
        )
        .expect_err("missing actor type must be unrepresentable");
        assert!(matches!(
            error,
            ProviderError::Unrepresentable { fact, .. } if fact.contains("has no type")
        ));
    }
}