feat: make term testable

Author: ymgyt

.helix/languages.toml

@@ -24,4 +24,8 @@ lens.enable = false
 hover.actions.enable = false
 
 [language-server.rust-analyzer.config.cargo]
-features = ["auth_static_fut", "introspection"]
+features = ["introspection", "integration"]
+
+[language-server.rust-analyzer.config.check]
+command = "clippy"
+features = "all"

Cargo.lock

@@ -17,6 +17,9 @@ fmt: fmt-toml
 fmt-toml:
   taplo fmt **.toml
 
+# Run integration test
+integration:
+  RUST_LOG="syndterm,integration=debug" cargo nextest run --package syndterm --features integration --test integration --no-capture 
 
 update-gql-schema:
   @graphql-client introspect-schema http://localhost:5959/graphql \

justfile

@@ -49,4 +49,3 @@ pin-project = "1.1.4"
 
 # Enable graphql introspection
 introspection = []
-auth_static_fut = []

syndapi/Cargo.toml

@@ -7,6 +7,10 @@ license.workspace = true
 categories.workspace = true
 repository.workspace = true
 
+[[bin]]
+name = "synd"
+path = "src/main.rs"
+
 [dependencies]
 anyhow = { workspace = true }
 clap = { workspace = true, features = ["derive", "string"] }
@@ -27,13 +31,24 @@ reqwest = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
 serde_json = "1.0.111"
 synd = { path = "../synd" }
-tokio = { workspace = true, features = ["macros", "rt-multi-thread", "sync"] }
+tokio = { workspace = true, features = [
+  "macros",
+  "rt-multi-thread",
+  "sync",
+  "time",
+] }
 tracing = { workspace = true }
 tracing-appender = "0.2.3"
 tracing-subscriber = { workspace = true }
 url = { workspace = true }
 unicode-segmentation = "1.10.1"
 
-[[bin]]
-name = "synd"
-path = "src/main.rs"
+[features]
+# Integration test
+integration = []
+
+[dev-dependencies]
+serial_test = { version = "3.0.0", default_features = false, features = [
+  "async",
+  "file_locks",
+] }

syndterm/Cargo.toml

@@ -1,3 +1,9 @@
+use std::{pin::Pin, time::Duration};
+
+use crossterm::event::{Event as CrosstermEvent, KeyCode, KeyEvent, KeyEventKind};
+use futures_util::{FutureExt, Stream, StreamExt};
+use tokio::time::{Instant, Sleep};
+
 use crate::{
     auth::{
         self,
@@ -18,8 +24,6 @@ use crate::{
         theme::Theme,
     },
 };
-use crossterm::event::{Event as CrosstermEvent, KeyCode, KeyEvent, KeyEventKind};
-use futures_util::{FutureExt, Stream, StreamExt};
 
 mod direction;
 pub use direction::{Direction, IndexOutOfRange};
@@ -58,10 +62,17 @@ pub struct Application {
     jobs: Jobs,
     state: State,
     theme: Theme,
+    idle_timer: Pin<Box<Sleep>>,
+
     should_render: bool,
     should_quit: bool,
 }
 
+#[derive(PartialEq, Eq)]
+pub enum EventLoopControlFlow {
+    Quit,
+}
+
 impl Application {
     pub fn new(terminal: Terminal, client: Client) -> Self {
         let state = State {
@@ -82,6 +93,7 @@ impl Application {
             jobs: Jobs::new(),
             state,
             theme: Theme::new(),
+            idle_timer: Box::pin(tokio::time::sleep(Duration::from_millis(250))),
             should_quit: false,
             should_render: false,
         }
@@ -112,8 +124,6 @@ impl Application {
     {
         self.terminal.init()?;
 
-        self.render();
-
         self.event_loop(input).await;
 
         self.terminal.exit()?;
@@ -122,6 +132,19 @@ impl Application {
     }
 
     async fn event_loop<S>(&mut self, input: &mut S)
+    where
+        S: Stream<Item = std::io::Result<CrosstermEvent>> + Unpin,
+    {
+        self.render();
+
+        loop {
+            if self.event_loop_until_idle(input).await == EventLoopControlFlow::Quit {
+                break;
+            }
+        }
+    }
+
+    pub async fn event_loop_until_idle<S>(&mut self, input: &mut S) -> EventLoopControlFlow
     where
         S: Stream<Item = std::io::Result<CrosstermEvent>> + Unpin,
     {
@@ -135,6 +158,9 @@ impl Application {
                 Some(command) = self.jobs.futures.next() => {
                     Some(command.unwrap())
                 }
+                _ = &mut self.idle_timer => {
+                    Some(Command::Idle)
+                }
             };
 
             if let Some(command) = command {
@@ -148,11 +174,12 @@ impl Application {
             }
 
             if self.should_quit {
-                break;
+                break EventLoopControlFlow::Quit;
             }
         }
     }
 
+    #[tracing::instrument(skip_all,fields(%command))]
     fn apply(&mut self, command: Command) {
         tracing::debug!("Apply {command:?}");
 
@@ -166,6 +193,9 @@ impl Application {
                 Command::ResizeTerminal { .. } => {
                     self.should_render = true;
                 }
+                Command::Idle => {
+                    self.handle_idle();
+                }
                 Command::Authenticate(method) => self.authenticate(method),
                 Command::DeviceAuthorizationFlow(device_authorization) => {
                     self.device_authorize_flow(device_authorization)
@@ -429,6 +459,7 @@ impl Application {
                         .device_authorize_request()
                         .await
                         .unwrap();
+
                     Ok(Command::DeviceAuthorizationFlow(res))
                 }
                 .boxed();
@@ -472,3 +503,29 @@ impl Application {
         self.set_auth(auth);
     }
 }
+
+impl Application {
+    fn handle_idle(&mut self) {
+        self.reset_idle_timer();
+
+        #[cfg(feature = "integration")]
+        {
+            self.should_render = true;
+            self.should_quit = true;
+        }
+    }
+
+    fn reset_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));
+    }
+}
+
+#[cfg(feature = "integration")]
+impl Application {
+    pub fn assert_buffer(&self, expected: &ratatui::buffer::Buffer) {
+        self.terminal.assert_buffer(expected)
+    }
+}

syndterm/src/application/mod.rs

@@ -1,3 +1,5 @@
+use std::fmt::Display;
+
 use crate::{
     application::{AuthenticateMethod, Direction},
     auth::device_flow::{DeviceAccessTokenResponse, DeviceAuthorizationResponse},
@@ -9,6 +11,7 @@ use crate::{
 pub enum Command {
     Quit,
     ResizeTerminal { columns: u16, rows: u16 },
+    Idle,
 
     Authenticate(AuthenticateMethod),
     DeviceAuthorizationFlow(DeviceAuthorizationResponse),
@@ -36,3 +39,13 @@ pub enum Command {
 
     HandleError { message: String },
 }
+
+impl Display for Command {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Command::UpdateSubscription(_) => f.write_str("UpdateSubscription"),
+            Command::UpdateEntries(_) => f.write_str("UpdateEntries"),
+            cmd => write!(f, "{:?}", cmd),
+        }
+    }
+}

syndterm/src/command.rs

@@ -54,8 +54,7 @@ async fn main() {
     let _guard = init_tracing(log).unwrap();
 
     let mut app = {
-        let terminal =
-            Terminal::from_stdout(std::io::stdout()).expect("Failed to construct terminal");
+        let terminal = Terminal::new().expect("Failed to construct terminal");
         let client = Client::new(endpoint).expect("Failed to construct client");
         Application::new(terminal, client)
     };

syndterm/src/main.rs

@@ -0,0 +1,7 @@
+use ratatui::backend::CrosstermBackend;
+
+pub type TerminalBackend = CrosstermBackend<std::io::Stdout>;
+
+pub fn new_backend() -> TerminalBackend {
+    CrosstermBackend::new(std::io::stdout())
+}

syndterm/src/terminal/backend.rs

@@ -0,0 +1,9 @@
+use ratatui::backend::TestBackend;
+
+pub type Buffer = ratatui::buffer::Buffer;
+
+pub type TerminalBackend = TestBackend;
+
+pub fn new_backend() -> TerminalBackend {
+    TestBackend::new(10, 10)
+}

syndterm/src/terminal/integration_backend.rs

@@ -1,24 +1,32 @@
 use anyhow::Result;
 use crossterm::terminal::{self, EnterAlternateScreen, LeaveAlternateScreen};
-use ratatui::{backend::CrosstermBackend, Frame};
+use ratatui::Frame;
 use std::io;
 
-type TerminalBackend = ratatui::Terminal<CrosstermBackend<io::Stdout>>;
+#[cfg(not(feature = "integration"))]
+mod backend;
+#[cfg(not(feature = "integration"))]
+pub use backend::{new_backend, TerminalBackend};
+
+#[cfg(feature = "integration")]
+mod integration_backend;
+#[cfg(feature = "integration")]
+pub use integration_backend::{new_backend, Buffer, TerminalBackend};
 
 /// Provide terminal manipulation operations.
 pub struct Terminal {
-    backend: TerminalBackend,
+    backend: ratatui::Terminal<TerminalBackend>,
 }
 
 impl Terminal {
-    pub fn new(backend: TerminalBackend) -> Self {
-        Self { backend }
+    /// Construct Terminal with default backend
+    pub fn new() -> anyhow::Result<Self> {
+        let backend = new_backend();
+        Ok(Terminal::with(ratatui::Terminal::new(backend)?))
     }
 
-    /// Construct Terminal from stdout
-    pub fn from_stdout(out: io::Stdout) -> Result<Self> {
-        let backend = CrosstermBackend::new(out);
-        Ok(Terminal::new(ratatui::Terminal::new(backend)?))
+    pub fn with(backend: ratatui::Terminal<TerminalBackend>) -> Self {
+        Self { backend }
     }
 
     /// Initialize terminal
@@ -59,4 +67,9 @@ impl Terminal {
         self.backend.draw(f)?;
         Ok(())
     }
+
+    #[cfg(feature = "integration")]
+    pub fn assert_buffer(&self, expected: &Buffer) {
+        self.backend.backend().assert_buffer(expected)
+    }
 }