Add snapshot test using insta (#2411)

Author: cruessler

Cargo.lock

@@ -89,6 +89,8 @@ chrono = { version = "0.4", default-features = false, features = ["clock"] }
 
 [dev-dependencies]
 env_logger = "0.11"
+git2-testing = { path = "./git2-testing" }
+insta = { version = "1.41.0", features = ["filters"] }
 pretty_assertions = "1.4"
 tempfile = "3"
 

Cargo.toml

@@ -20,13 +20,18 @@ pub fn repo_init_empty() -> (TempDir, Repository) {
 	(td, repo)
 }
 
-/// initialize test repo in temp path with an empty first commit
-pub fn repo_init() -> (TempDir, Repository) {
+/// initialize test repo in temp path with given suffix and an empty first commit
+pub fn repo_init_suffix<T: AsRef<std::ffi::OsStr>>(
+	suffix: Option<T>,
+) -> (TempDir, Repository) {
 	init_log();
 
 	sandbox_config_files();
 
-	let td = TempDir::new().unwrap();
+	let td = match suffix {
+		Some(suffix) => TempDir::with_suffix(suffix).unwrap(),
+		None => TempDir::new().unwrap(),
+	};
 	let repo = Repository::init(td.path()).unwrap();
 	{
 		let mut config = repo.config().unwrap();
@@ -45,6 +50,11 @@ pub fn repo_init() -> (TempDir, Repository) {
 	(td, repo)
 }
 
+/// initialize test repo in temp path with an empty first commit
+pub fn repo_init() -> (TempDir, Repository) {
+	repo_init_suffix::<&std::ffi::OsStr>(None)
+}
+
 // init log
 fn init_log() {
 	let _ = env_logger::builder()

git2-testing/src/lib.rs

@@ -0,0 +1,280 @@
+use std::time::Instant;
+
+use anyhow::Result;
+use asyncgit::{sync::utils::repo_work_dir, AsyncGitNotification};
+use crossbeam_channel::{never, tick, unbounded, Receiver};
+use scopetime::scope_time;
+
+#[cfg(test)]
+use crossterm::event::{KeyCode, KeyModifiers};
+
+use crate::{
+	app::{App, QuitState},
+	args::CliArgs,
+	draw,
+	input::{Input, InputEvent, InputState},
+	keys::KeyConfig,
+	select_event,
+	spinner::Spinner,
+	ui::style::Theme,
+	watcher::RepoWatcher,
+	AsyncAppNotification, AsyncNotification, QueueEvent, Updater,
+	SPINNER_INTERVAL, TICK_INTERVAL,
+};
+
+pub struct Gitui {
+	app: crate::app::App,
+	rx_input: Receiver<InputEvent>,
+	rx_git: Receiver<AsyncGitNotification>,
+	rx_app: Receiver<AsyncAppNotification>,
+	rx_ticker: Receiver<Instant>,
+	rx_watcher: Receiver<()>,
+}
+
+impl Gitui {
+	pub(crate) fn new(
+		cliargs: CliArgs,
+		theme: Theme,
+		key_config: &KeyConfig,
+		updater: Updater,
+	) -> Result<Self, anyhow::Error> {
+		let (tx_git, rx_git) = unbounded();
+		let (tx_app, rx_app) = unbounded();
+
+		let input = Input::new();
+
+		let (rx_ticker, rx_watcher) = match updater {
+			Updater::NotifyWatcher => {
+				let repo_watcher = RepoWatcher::new(
+					repo_work_dir(&cliargs.repo_path)?.as_str(),
+				);
+
+				(never(), repo_watcher.receiver())
+			}
+			Updater::Ticker => (tick(TICK_INTERVAL), never()),
+		};
+
+		let app = App::new(
+			cliargs,
+			tx_git,
+			tx_app,
+			input.clone(),
+			theme,
+			key_config.clone(),
+		)?;
+
+		Ok(Self {
+			app,
+			rx_input: input.receiver(),
+			rx_git,
+			rx_app,
+			rx_ticker,
+			rx_watcher,
+		})
+	}
+
+	pub(crate) fn run_main_loop<B: ratatui::backend::Backend>(
+		&mut self,
+		terminal: &mut ratatui::Terminal<B>,
+	) -> Result<QuitState, anyhow::Error> {
+		let spinner_ticker = tick(SPINNER_INTERVAL);
+		let mut spinner = Spinner::default();
+
+		self.app.update()?;
+
+		loop {
+			let event = select_event(
+				&self.rx_input,
+				&self.rx_git,
+				&self.rx_app,
+				&self.rx_ticker,
+				&self.rx_watcher,
+				&spinner_ticker,
+			)?;
+
+			{
+				if matches!(event, QueueEvent::SpinnerUpdate) {
+					spinner.update();
+					spinner.draw(terminal)?;
+					continue;
+				}
+
+				scope_time!("loop");
+
+				match event {
+					QueueEvent::InputEvent(ev) => {
+						if matches!(
+							ev,
+							InputEvent::State(InputState::Polling)
+						) {
+							//Note: external ed closed, we need to re-hide cursor
+							terminal.hide_cursor()?;
+						}
+						self.app.event(ev)?;
+					}
+					QueueEvent::Tick | QueueEvent::Notify => {
+						self.app.update()?;
+					}
+					QueueEvent::AsyncEvent(ev) => {
+						if !matches!(
+							ev,
+							AsyncNotification::Git(
+								AsyncGitNotification::FinishUnchanged
+							)
+						) {
+							self.app.update_async(ev)?;
+						}
+					}
+					QueueEvent::SpinnerUpdate => unreachable!(),
+				}
+
+				self.draw(terminal)?;
+
+				spinner.set_state(self.app.any_work_pending());
+				spinner.draw(terminal)?;
+
+				if self.app.is_quit() {
+					break;
+				}
+			}
+		}
+
+		Ok(self.app.quit_state())
+	}
+
+	fn draw<B: ratatui::backend::Backend>(
+		&self,
+		terminal: &mut ratatui::Terminal<B>,
+	) -> std::io::Result<()> {
+		draw(terminal, &self.app)
+	}
+
+	#[cfg(test)]
+	fn update_async(&mut self, event: crate::AsyncNotification) {
+		self.app.update_async(event).unwrap();
+	}
+
+	#[cfg(test)]
+	fn input_event(
+		&mut self,
+		code: KeyCode,
+		modifiers: KeyModifiers,
+	) {
+		let event = crossterm::event::KeyEvent::new(code, modifiers);
+		self.app
+			.event(crate::input::InputEvent::Input(
+				crossterm::event::Event::Key(event),
+			))
+			.unwrap();
+	}
+
+	#[cfg(test)]
+	fn wait_for_async_git_notification(
+		&self,
+		expected: AsyncGitNotification,
+	) {
+		loop {
+			let actual = self
+				.rx_git
+				.recv_timeout(std::time::Duration::from_millis(100))
+				.unwrap();
+
+			if actual == expected {
+				break;
+			}
+		}
+	}
+
+	#[cfg(test)]
+	fn update(&mut self) {
+		self.app.update().unwrap();
+	}
+}
+
+#[cfg(test)]
+mod tests {
+	use std::path::PathBuf;
+
+	use asyncgit::{sync::RepoPath, AsyncGitNotification};
+	use crossterm::event::{KeyCode, KeyModifiers};
+	use git2_testing::repo_init_suffix;
+	use insta::assert_snapshot;
+	use ratatui::{backend::TestBackend, Terminal};
+
+	use crate::{
+		args::CliArgs, gitui::Gitui, keys::KeyConfig,
+		ui::style::Theme, AsyncNotification, Updater,
+	};
+
+	// Macro adapted from: https://insta.rs/docs/cmd/
+	macro_rules! apply_common_filters {
+		{} => {
+			let mut settings = insta::Settings::clone_current();
+			// Windows and MacOS
+			// We don't match on the full path, but on the suffix we pass to `repo_init_suffix` below.
+			settings.add_filter(r" *\[…\]\S+-insta/?", "[TEMP_FILE]");
+			// Linux Temp Folder
+			settings.add_filter(r" */tmp/\.tmp\S+-insta/", "[TEMP_FILE]");
+			// Commit ids that follow a vertical bar
+			settings.add_filter(r"│[a-z0-9]{7} ", "│[AAAAA] ");
+			let _bound = settings.bind_to_scope();
+		}
+	}
+
+	#[test]
+	fn gitui_starts() {
+		apply_common_filters!();
+
+		let (temp_dir, _repo) = repo_init_suffix(Some("-insta"));
+		let path: RepoPath = temp_dir.path().to_str().unwrap().into();
+		let cliargs = CliArgs {
+			theme: PathBuf::from("theme.ron"),
+			select_file: None,
+			repo_path: path,
+			notify_watcher: false,
+			key_bindings_path: None,
+			key_symbols_path: None,
+		};
+
+		let theme = Theme::init(&PathBuf::new());
+		let key_config = KeyConfig::default();
+
+		let mut gitui =
+			Gitui::new(cliargs, theme, &key_config, Updater::Ticker)
+				.unwrap();
+
+		let mut terminal =
+			Terminal::new(TestBackend::new(90, 12)).unwrap();
+
+		gitui.draw(&mut terminal).unwrap();
+
+		assert_snapshot!("app_loading", terminal.backend());
+
+		let event =
+			AsyncNotification::Git(AsyncGitNotification::Status);
+		gitui.update_async(event);
+
+		gitui.draw(&mut terminal).unwrap();
+
+		assert_snapshot!("app_loading_finished", terminal.backend());
+
+		gitui.input_event(KeyCode::Char('2'), KeyModifiers::empty());
+		gitui.input_event(
+			key_config.keys.tab_log.code,
+			key_config.keys.tab_log.modifiers,
+		);
+
+		gitui.wait_for_async_git_notification(
+			AsyncGitNotification::Log,
+		);
+
+		gitui.update();
+
+		gitui.draw(&mut terminal).unwrap();
+
+		assert_snapshot!(
+			"app_log_tab_showing_one_commit",
+			terminal.backend()
+		);
+	}
+}