feat: Add support for exchanging oauth code for access token

src/auth.rs

@@ -1,7 +1,7 @@
 //! Authentication related types and functions.
 
-use crate::models::AppId;
 use crate::Result;
+use crate::{models::AppId, Octocrab};
 use either::Either;
 use jsonwebtoken::{Algorithm, EncodingKey, Header};
 use secrecy::{ExposeSecret, SecretString};
@@ -258,6 +258,58 @@ impl DeviceCodes {
     }
 }
 
+#[derive(serde::Serialize)]
+pub struct ExchangeWebFlowCodeBuilder<'octo, 'client_id, 'code, 'client_secret, 'redirect_uri> {
+    #[serde(skip)]
+    crab: &'octo Octocrab,
+    client_id: &'client_id str,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    code: Option<&'code str>,
+    client_secret: &'client_secret str,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    redirect_uri: Option<&'redirect_uri str>,
+}
+
+impl<'octo, 'client_id, 'code, 'client_secret, 'redirect_uri>
+    ExchangeWebFlowCodeBuilder<'octo, 'client_id, 'code, 'client_secret, 'redirect_uri>
+{
+    pub fn new(
+        crab: &'octo Octocrab,
+        client_id: &'client_id SecretString,
+        client_secret: &'client_secret SecretString,
+    ) -> Self {
+        Self {
+            crab,
+            client_id: client_id.expose_secret(),
+            code: None,
+            client_secret: client_secret.expose_secret(),
+            redirect_uri: None,
+        }
+    }
+
+    /// Set the `code` for exchange web flow code request to be created.
+    pub fn code(mut self, code: &'code str) -> Self {
+        self.code = Some(code);
+        self
+    }
+
+    /// Set the `redirect_uri` for exchange web flow code request to be created.
+    pub fn redirect_uri(mut self, redirect_uri: &'redirect_uri str) -> Self {
+        self.redirect_uri = Some(redirect_uri);
+        self
+    }
+
+    /// Sends the actual request.
+    /// Exchange a code for a user access token
+    ///
+    /// see: https://docs.github.com/en/developers/apps/identifying-and-authorizing-users-for-github-apps
+    ///
+    pub async fn send(self) -> crate::Result<OAuth> {
+        let route = "/login/oauth/access_token";
+        self.crab.post(route, Some(&self)).await
+    }
+}
+
 /// See https://docs.github.com/en/developers/apps/building-oauth-apps/authorizing-oauth-apps#input-parameters
 #[derive(Serialize)]
 struct DeviceFlow<'a> {

tests/auth_exchange_web_flow_code_test.rs

@@ -0,0 +1,81 @@
+mod mock_error;
+
+use mock_error::setup_error_handler;
+use octocrab::{
+    auth::{self, ExchangeWebFlowCodeBuilder},
+    Octocrab,
+};
+use secrecy::SecretString;
+use serde_json::json;
+use wiremock::{
+    matchers::{method, path},
+    Mock, MockServer, ResponseTemplate,
+};
+
+async fn setup_post_api(template: ResponseTemplate) -> MockServer {
+    let mock_server = MockServer::start().await;
+
+    Mock::given(method("POST"))
+        .and(path(format!("/login/oauth/access_token")))
+        .respond_with(template.clone())
+        .mount(&mock_server)
+        .await;
+
+    setup_error_handler(
+        &mock_server,
+        &format!("POST on /login/oauth/access_token was not received"),
+    )
+    .await;
+    mock_server
+}
+
+fn setup_octocrab(uri: &str) -> Octocrab {
+    Octocrab::builder().base_uri(uri).unwrap().build().unwrap()
+}
+
+const CLIENT_SECRET: &str = "some_secret";
+const CLIENT_ID: &str = "some_client_id";
+const CODE: &str = "a_code";
+const REDIRECT_URI: &str = "https://yourapp/auth/callback-example";
+
+#[tokio::test]
+async fn should_return_oauth_response() {
+    let expected_response = json!({
+        "access_token":"gho_16C7e42F292c6912E7710c838347Ae178B4a",
+        "scope":"repo,gist",
+        "token_type":"bearer"
+        }
+    );
+    let template = ResponseTemplate::new(201).set_body_json(expected_response);
+    let mock_server = setup_post_api(template).await;
+    let client = setup_octocrab(&mock_server.uri());
+
+    let result = auth::ExchangeWebFlowCodeBuilder::new(
+        &client,
+        &SecretString::from(CLIENT_ID),
+        &SecretString::from(CLIENT_SECRET),
+    )
+    .code(CODE)
+    .redirect_uri(REDIRECT_URI.to_owned())
+    .send()
+    .await;
+
+    assert!(result.is_ok());
+}
+
+#[tokio::test]
+async fn should_fail_when_receving_a_server_error() {
+    let template = ResponseTemplate::new(500);
+    let mock_server = setup_post_api(template).await;
+    let client = setup_octocrab(&mock_server.uri());
+
+    let result = auth::ExchangeWebFlowCodeBuilder::new(
+        &client,
+        &SecretString::from(CLIENT_ID),
+        &SecretString::from(CLIENT_SECRET),
+    )
+    .send()
+    .await;
+
+    assert!(result.is_err());
+}