test: impl device flow test case

Author: ymgyt

Cargo.lock

@@ -12,24 +12,18 @@ readme      = "README"
 repository  = "https://github.com/ymgyt/syndicationd"
 
 [workspace.dependencies]
-anyhow = { version = "1" }
-async-trait = { version = "0.1.77" }
-chrono = { version = "0.4.31" }
-clap = { version = "4.4" }
-feed-rs = { version = "1.4" }
-futures-util = { version = "0.3.30" }
-graphql_client = { version = "0.13.0", default-features = false }
-moka = { version = "0.12.4", features = ["future"] }
-reqwest = { version = "0.11.23", default-features = false, features = ["rustls-tls", "json"] }
-serde = { version = "1", features = ["derive"] }
-tokio = { version = "1.35" }
-tracing = { version = "0.1.40" }
-tracing-subscriber = { version = "0.3.18", features = [
-  "smallvec",
-  "fmt",
-  "ansi",
-  "std",
-  "env-filter",
-  "time",
-], default-features = false }
-url = { version = "2.5.0" }
+anyhow             = { version = "1" }
+async-trait        = { version = "0.1.77" }
+axum               = { version = "0.7.4" }
+chrono             = { version = "0.4.31" }
+clap               = { version = "4.4" }
+feed-rs            = { version = "1.4" }
+futures-util       = { version = "0.3.30" }
+graphql_client     = { version = "0.13.0", default-features = false }
+moka               = { version = "0.12.4", features = ["future"] }
+reqwest            = { version = "0.11.23", default-features = false, features = ["rustls-tls", "json"] }
+serde              = { version = "1", features = ["derive"] }
+tokio              = { version = "1.35" }
+tracing            = { version = "0.1.40" }
+tracing-subscriber = { version = "0.3.18", features = ["smallvec", "fmt", "ansi", "std", "env-filter", "time"], default-features = false }
+url                = { version = "2.5.0" }

Cargo.toml

@@ -15,7 +15,7 @@ async-graphql      = { version = "7.0", features = ["tracing"] }
 async-graphql-axum = { version = "7.0" }
 async-trait        = { workspace = true }
 # TODO configure features
-axum               = { version = "0.7.4" }
+axum               = { workspace = true }
 chrono             = { workspace = true }
 clap               = { workspace = true, features = ["derive"] }
 feed-rs            = { workspace = true }

crates/synd_api/Cargo.toml

@@ -44,4 +44,5 @@ integration = []
 
 [dev-dependencies]
 serial_test  = { version = "3.0.0", default_features = false, features = ["async", "file_locks"] }
+synd_test    = { path = "../synd_test" }
 tokio-stream = "0.1.14"

crates/synd_term/Cargo.toml

@@ -9,6 +9,7 @@ use crate::{
     auth::{
         self,
         device_flow::{DeviceAccessTokenResponse, DeviceAuthorizationResponse},
+        github::DeviceFlow,
         AuthenticationProvider, Credential,
     },
     client::Client,
@@ -37,12 +38,14 @@ pub enum EventLoopControlFlow {
 
 pub struct Config {
     pub idle_timer_interval: Duration,
+    pub github_device_flow: DeviceFlow,
 }
 
 impl Default for Config {
     fn default() -> Self {
         Self {
             idle_timer_interval: Duration::from_secs(250),
+            github_device_flow: DeviceFlow::new(),
         }
     }
 }
@@ -435,12 +438,10 @@ impl Application {
         tracing::info!("Start authenticate");
         match provider {
             AuthenticationProvider::Github => {
+                let device_flow = self.config.github_device_flow.clone();
                 let fut = async move {
                     // TODO: error handling
-                    let res = auth::github::DeviceFlow::new()
-                        .device_authorize_request()
-                        .await
-                        .unwrap();
+                    let res = device_flow.device_authorize_request().await.unwrap();
 
                     Ok(Command::DeviceAuthorizationFlow(res))
                 }

crates/synd_term/src/application/mod.rs

@@ -1,15 +1,17 @@
+use std::borrow::Cow;
+
 use http::Uri;
 use serde::{Deserialize, Serialize};
 
 /// https://datatracker.ietf.org/doc/html/rfc8628#section-3.1
-#[derive(Serialize)]
+#[derive(Serialize, Deserialize, Debug)]
 pub struct DeviceAuthorizationRequest<'s> {
-    pub client_id: &'s str,
-    pub scope: &'s str,
+    pub client_id: Cow<'s, str>,
+    pub scope: Cow<'s, str>,
 }
 
 /// https://datatracker.ietf.org/doc/html/rfc8628#section-3.2
-#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub struct DeviceAuthorizationResponse {
     /// device verification code
     pub device_code: String,

crates/synd_term/src/auth/device_flow.rs

@@ -13,9 +13,11 @@ use crate::{
 };
 
 /// https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/authorizing-oauth-apps#device-flow
+#[derive(Clone)]
 pub struct DeviceFlow {
     client: Client,
     client_id: &'static str,
+    endpoint: Option<&'static str>,
 }
 
 impl DeviceFlow {
@@ -32,6 +34,14 @@ impl DeviceFlow {
         Self {
             client,
             client_id: config::github::CLIENT_ID,
+            endpoint: None,
+        }
+    }
+
+    pub fn with_endpoint(self, endpoint: &'static str) -> Self {
+        Self {
+            endpoint: Some(endpoint),
+            ..self
         }
     }
 
@@ -44,11 +54,11 @@ impl DeviceFlow {
 
         let response = self
             .client
-            .post(Self::DEVICE_AUTHORIZATION_ENDPOINT)
+            .post(self.endpoint.unwrap_or(Self::DEVICE_AUTHORIZATION_ENDPOINT))
             .header(http::header::ACCEPT, "application/json")
             .form(&DeviceAuthorizationRequest {
-                client_id: self.client_id,
-                scope,
+                client_id: self.client_id.into(),
+                scope: scope.into(),
             })
             .send()
             .await?

crates/synd_term/src/auth/github.rs

@@ -12,29 +12,38 @@ mod test {
     use serial_test::file_serial;
     use synd_term::{
         application::{Application, Config},
+        auth::github::DeviceFlow,
         client::Client,
         ui::theme::Theme,
     };
+    use tokio::net::TcpListener;
     use tokio_stream::wrappers::UnboundedReceiverStream;
-    use tracing::Level;
+    use tracing_subscriber::EnvFilter;
 
     #[tokio::test(flavor = "multi_thread")]
     #[file_serial(a)]
     async fn hello_world() -> anyhow::Result<()> {
         // TODO: wrap once
         tracing_subscriber::fmt()
-            .with_max_level(Level::DEBUG)
+            .with_env_filter(EnvFilter::from_default_env())
             .with_line_number(true)
             .with_file(true)
+            .with_target(false)
             .init();
 
         tracing::info!("TEST hello_world run");
 
+        let oauth_addr = ("127.0.0.1", 6000);
+        let oauth_listener = TcpListener::bind(oauth_addr).await?;
+        tokio::spawn(synd_test::oauth::serve(oauth_listener));
+
         let endpoint = "http://localhost:5960".parse().unwrap();
         let terminal = helper::new_test_terminal();
         let client = Client::new(endpoint).unwrap();
         let config = Config {
             idle_timer_interval: Duration::from_millis(2000),
+            github_device_flow: DeviceFlow::new()
+                .with_endpoint("http://localhost:6000/github/login/device/code"),
         };
         // or mpsc and tokio_stream ReceiverStream
         let (tx, rx) = tokio::sync::mpsc::unbounded_channel();

crates/synd_term/tests/integration.rs

@@ -9,6 +9,8 @@ readme.workspace      = true
 repository.workspace  = true
 version               = "0.1.0"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [dependencies]
+anyhow    = { workspace = true }
+axum      = { workspace = true }
+synd_term = { path = "../synd_term" }
+tokio     = { workspace = true, features = ["rt-multi-thread", "net"] }

crates/synd_test/Cargo.toml

@@ -0,0 +1 @@
+pub mod oauth;

crates/synd_test/src/lib.rs

@@ -0,0 +1,29 @@
+use axum::{http::StatusCode, routing::post, Form, Json, Router};
+use synd_term::auth::device_flow::{DeviceAuthorizationRequest, DeviceAuthorizationResponse};
+use tokio::net::TcpListener;
+
+async fn device_authorization(
+    Form(DeviceAuthorizationRequest { scope, .. }): Form<DeviceAuthorizationRequest<'static>>,
+) -> Result<Json<DeviceAuthorizationResponse>, StatusCode> {
+    if scope != "user:email" {
+        return Err(StatusCode::BAD_REQUEST);
+    }
+    let res = DeviceAuthorizationResponse {
+        device_code: "DC001".into(),
+        user_code: "UC123456".into(),
+        verification_uri: "https://syndicationd.ymgyt.io/test".parse().unwrap(),
+        verification_uri_complete: None,
+        expires_in: 3600,
+        interval: None,
+    };
+
+    Ok(Json(res))
+}
+
+pub async fn serve(listener: TcpListener) -> anyhow::Result<()> {
+    let router = Router::new().route("/github/login/device/code", post(device_authorization));
+
+    axum::serve(listener, router).await?;
+
+    Ok(())
+}

crates/synd_test/src/oauth.rs

@@ -20,11 +20,11 @@ lint:
 
 # Format toml files
 fmt-toml:
-  taplo fmt **.toml
+  taplo fmt --config taplo.toml **.toml
 
 # Run integration test
 integration:
-  RUST_LOG="synd_term,integration=debug" cargo nextest run --package syndterm --features integration --test integration --no-capture 
+  RUST_LOG="synd_term,integration=debug" cargo nextest run --package synd_term --features integration --test integration --no-capture 
 
 update-gql-schema:
   @graphql-client introspect-schema http://localhost:5959/graphql \

justfile

@@ -2,5 +2,5 @@ include = ["Cargo.toml", "crates/**/Cargo.toml"]
 
 [formatting]
 align_entries = true
-column_width  = 120
+column_width  = 200
 reorder_keys  = true