test: add integration

Author: ymgyt

Cargo.lock

@@ -52,3 +52,4 @@ serial_test = { version = "3.0.0", default_features = false, features = [
   "async",
   "file_locks",
 ] }
+tokio-stream = "0.1.14"

syndterm/Cargo.toml

@@ -30,34 +30,52 @@ enum Screen {
     Browse,
 }
 
+#[derive(PartialEq, Eq)]
+pub enum EventLoopControlFlow {
+    Quit,
+}
+
+pub struct Config {
+    pub idle_timer_interval: Duration,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            idle_timer_interval: Duration::from_secs(250),
+        }
+    }
+}
+
 pub struct Application {
     terminal: Terminal,
     client: Client,
     jobs: Jobs,
     components: Components,
     theme: Theme,
     idle_timer: Pin<Box<Sleep>>,
+    config: Config,
 
     screen: Screen,
     should_render: bool,
     should_quit: bool,
 }
 
-#[derive(PartialEq, Eq)]
-pub enum EventLoopControlFlow {
-    Quit,
-}
-
 impl Application {
     pub fn new(terminal: Terminal, client: Client) -> Self {
+        Application::with(terminal, client, Config::default())
+    }
+
+    pub fn with(terminal: Terminal, client: Client, config: Config) -> Self {
         Self {
             terminal,
             client,
             components: Components::new(),
             jobs: Jobs::new(),
             theme: Theme::new(),
-            idle_timer: Box::pin(tokio::time::sleep(Duration::from_millis(250))),
+            idle_timer: Box::pin(tokio::time::sleep(config.idle_timer_interval)),
             screen: Screen::Login,
+            config,
             should_quit: false,
             should_render: false,
         }
@@ -138,15 +156,14 @@ impl Application {
             }
 
             if self.should_quit {
+                self.should_quit = false; // for testing
                 break EventLoopControlFlow::Quit;
             }
         }
     }
 
     #[tracing::instrument(skip_all,fields(%command))]
     fn apply(&mut self, command: Command) {
-        tracing::debug!("Apply {command:?}");
-
         let mut next = Some(command);
 
         // how to handle command => command pattern ?
@@ -259,7 +276,9 @@ impl Application {
                 ..
             }) => None,
             CrosstermEvent::Key(key) => {
-                tracing::debug!("{key:?}");
+                self.reset_idle_timer();
+
+                tracing::debug!("Handle key event: {key:?}");
                 match self.screen {
                     Screen::Login => match key.code {
                         KeyCode::Enter => {
@@ -411,7 +430,9 @@ impl Application {
 }
 
 impl Application {
+    #[tracing::instrument(skip(self))]
     fn authenticate(&mut self, provider: AuthenticationProvider) {
+        tracing::info!("Start authenticate");
         match provider {
             AuthenticationProvider::Github => {
                 let fut = async move {
@@ -469,21 +490,28 @@ impl Application {
 
 impl Application {
     fn handle_idle(&mut self) {
-        self.reset_idle_timer();
+        self.clear_idle_timer();
 
         #[cfg(feature = "integration")]
         {
+            tracing::debug!("Quit for idle");
             self.should_render = true;
             self.should_quit = true;
         }
     }
 
-    fn reset_idle_timer(&mut self) {
+    fn clear_idle_timer(&mut self) {
         // https://github.com/tokio-rs/tokio/blob/e53b92a9939565edb33575fff296804279e5e419/tokio/src/time/instant.rs#L62
         self.idle_timer
             .as_mut()
             .reset(Instant::now() + Duration::from_secs(86400 * 365 * 30));
     }
+
+    fn reset_idle_timer(&mut self) {
+        self.idle_timer
+            .as_mut()
+            .reset(Instant::now() + self.config.idle_timer_interval);
+    }
 }
 
 #[cfg(feature = "integration")]

syndterm/src/application/mod.rs

@@ -35,7 +35,10 @@ impl DeviceFlow {
         }
     }
 
+    #[tracing::instrument(skip(self))]
     pub async fn device_authorize_request(&self) -> anyhow::Result<DeviceAuthorizationResponse> {
+        tracing::debug!("Sending request");
+
         // https://docs.github.com/en/apps/oauth-apps/building-oauth-apps/scopes-for-oauth-apps
         let scope = "user:email";
 
@@ -53,6 +56,8 @@ impl DeviceFlow {
             .json::<DeviceAuthorizationResponse>()
             .await?;
 
+        tracing::debug!("Got response");
+
         Ok(response)
     }
 

syndterm/src/auth/github.rs

@@ -2,33 +2,47 @@
 mod test {
     mod helper;
 
+    use std::time::Duration;
+
     use crossterm::event::{Event, KeyCode, KeyEvent};
-    use futures_util::stream;
     use ratatui::{
         prelude::Buffer,
         style::{Modifier, Style},
     };
     use serial_test::file_serial;
-    use syndterm::{application::Application, client::Client, ui::theme::Theme};
+    use syndterm::{
+        application::{Application, Config},
+        client::Client,
+        ui::theme::Theme,
+    };
+    use tokio_stream::wrappers::UnboundedReceiverStream;
+    use tracing::Level;
 
     #[tokio::test(flavor = "multi_thread")]
     #[file_serial(a)]
     async fn hello_world() -> anyhow::Result<()> {
         // TODO: wrap once
-        tracing_subscriber::fmt::init();
+        tracing_subscriber::fmt()
+            .with_max_level(Level::DEBUG)
+            .with_line_number(true)
+            .with_file(true)
+            .init();
 
         tracing::info!("TEST hello_world run");
 
         let endpoint = "http://localhost:5960".parse().unwrap();
         let terminal = helper::new_test_terminal();
         let client = Client::new(endpoint).unwrap();
-        let mut application = Application::new(terminal, client);
-        let _event = Event::Key(KeyEvent::from(KeyCode::Char('j')));
+        let config = Config {
+            idle_timer_interval: Duration::from_millis(2000),
+        };
         // or mpsc and tokio_stream ReceiverStream
-        let mut event_stream = stream::iter(vec![]);
+        let (tx, rx) = tokio::sync::mpsc::unbounded_channel();
+        let mut event_stream = UnboundedReceiverStream::new(rx);
         let theme = Theme::new();
         let bg = theme.background.bg.unwrap_or_default();
 
+        let mut application = Application::with(terminal, client, config);
         application.event_loop_until_idle(&mut event_stream).await;
 
         // login
@@ -74,6 +88,13 @@ mod test {
 
         application.assert_buffer(&expected);
 
+        tracing::info!("Login assertion OK");
+
+        // push enter => start auth flow
+        let event = Event::Key(KeyEvent::from(KeyCode::Enter));
+        tx.send(Ok(event)).unwrap();
+        application.event_loop_until_idle(&mut event_stream).await;
+
         Ok(())
     }
 }