test updates

Author: MitMaro

Cargo.toml

@@ -214,6 +214,7 @@ redundant_closure_for_method_calls = "allow"
 redundant_pub_crate = "allow"
 ref_patterns = "allow"
 self_named_module_files = "allow"
+semicolon_outside_block = "allow"
 single_call_fn = "allow"
 std_instead_of_alloc = "allow"
 std_instead_of_core = "allow"

src/application.rs

@@ -85,7 +85,7 @@ where ModuleProvider: module::ModuleProvider + Send + 'static
 		let commit_diff_loader = CommitDiffLoader::new(config_loader.eject_repository(), commit_diff_loader_options);
 
 		let diff_update_handler = Self::create_diff_update_handler(input_state.clone());
-		let diff_thread = diff::Thread::new(commit_diff_loader, diff_update_handler);
+		let diff_thread = diff::thread::Thread::new(commit_diff_loader, diff_update_handler);
 		let diff_state = diff_thread.state();
 		threads.push(Box::new(diff_thread));
 

src/application/app_data.rs

@@ -9,7 +9,7 @@ pub(crate) struct AppData {
 	config: Arc<Config>,
 	active_module: Arc<Mutex<module::State>>,
 	todo_file: Arc<Mutex<TodoFile>>,
-	diff_state: diff::State,
+	diff_state: diff::thread::State,
 	view_state: view::State,
 	input_state: input::State,
 	search_state: search::State,
@@ -20,7 +20,7 @@ impl AppData {
 		config: Config,
 		active_module: module::State,
 		todo_file: Arc<Mutex<TodoFile>>,
-		diff_state: diff::State,
+		diff_state: diff::thread::State,
 		view_state: view::State,
 		input_state: input::State,
 		search_state: search::State,
@@ -48,7 +48,7 @@ impl AppData {
 		Arc::clone(&self.todo_file)
 	}
 
-	pub(crate) fn diff_state(&self) -> diff::State {
+	pub(crate) fn diff_state(&self) -> diff::thread::State {
 		self.diff_state.clone()
 	}
 

src/diff.rs

@@ -1,4 +1,3 @@
-mod action;
 mod commit;
 mod commit_diff;
 mod commit_diff_loader;
@@ -14,12 +13,9 @@ mod reference_kind;
 mod status;
 mod user;
 
-mod state;
-mod thread;
-mod update_handler;
+pub(crate) mod thread;
 
 pub(crate) use self::{
-	action::Action,
 	commit::Commit,
 	commit_diff::CommitDiff,
 	commit_diff_loader::CommitDiffLoader,
@@ -32,9 +28,6 @@ pub(crate) use self::{
 	origin::Origin,
 	reference::Reference,
 	reference_kind::ReferenceKind,
-	state::{LoadStatus, State},
 	status::Status,
-	thread::Thread,
-	update_handler::UpdateHandlerFn,
 	user::User,
 };

src/diff/commit_diff_loader.rs

@@ -18,8 +18,8 @@ use crate::{
 		FileMode,
 		FileStatus,
 		FileStatusBuilder,
-		LoadStatus,
 		Status,
+		thread::LoadStatus,
 	},
 	git::GitError,
 };
@@ -62,12 +62,12 @@ impl CommitDiffLoader {
 		Arc::clone(&self.commit_diff)
 	}
 
-	fn diff<'r>(
-		repository: &'r Repository,
+	fn diff<'repo>(
+		repository: &'repo Repository,
 		config: &CommitDiffLoaderOptions,
 		commit: &git2::Commit<'_>,
 		diff_options: &mut DiffOptions,
-	) -> Result<Diff<'r>, GitError> {
+	) -> Result<Diff<'repo>, GitError> {
 		_ = diff_options
 			.context_lines(config.context_lines)
 			.ignore_filemode(false)
@@ -154,8 +154,6 @@ impl CommitDiffLoader {
 		Ok(())
 	}
 
-	#[expect(clippy::as_conversions, reason = "Realistically safe conversion.")]
-	#[expect(clippy::unwrap_in_result, reason = "Unwrap usage failure considered a bug.")]
 	pub(crate) fn collect(
 		&self,
 		diff: &Diff<'_>,
@@ -863,18 +861,16 @@ mod tests {
 			let notifier = move |status| {
 				let mut c = notifier_calls.lock();
 				c.push(status);
-				return false;
+				false
 			};
 
 			_ = diff_with_notifier(repository, CommitDiffLoaderOptions::new(), notifier).unwrap();
 
 			let c = calls.lock();
-			assert_eq!(c.get(0).unwrap(), &LoadStatus::New);
+			assert_eq!(c.first().unwrap(), &LoadStatus::New);
 			assert_eq!(c.get(1).unwrap(), &LoadStatus::Diff(0, 10));
-			assert_eq!(c.get(2).unwrap(), &LoadStatus::Diff(3, 10));
-			assert_eq!(c.get(3).unwrap(), &LoadStatus::Diff(6, 10));
-			assert_eq!(c.get(4).unwrap(), &LoadStatus::Diff(9, 10));
-			assert_eq!(c.get(5).unwrap(), &LoadStatus::DiffComplete);
+			assert!(matches!(c.get(2).unwrap(), &LoadStatus::Diff(_, 10)));
+			assert!(matches!(c.last().unwrap(), &LoadStatus::DiffComplete));
 		});
 	}
 
@@ -891,23 +887,51 @@ mod tests {
 			let notifier = move |status| {
 				let mut c = notifier_calls.lock();
 				c.push(status);
-				return false;
+				false
 			};
 
 			_ = diff_with_notifier(repository, CommitDiffLoaderOptions::new().copies(true), notifier).unwrap();
 
-			let c = calls.lock();
-			assert_eq!(c.get(0).unwrap(), &LoadStatus::New);
-			assert_eq!(c.get(1).unwrap(), &LoadStatus::QuickDiff(0, 10));
-			assert_eq!(c.get(2).unwrap(), &LoadStatus::QuickDiff(3, 10));
-			assert_eq!(c.get(3).unwrap(), &LoadStatus::QuickDiff(6, 10));
-			assert_eq!(c.get(4).unwrap(), &LoadStatus::QuickDiff(9, 10));
-			assert_eq!(c.get(5).unwrap(), &LoadStatus::CompleteQuickDiff);
-			assert_eq!(c.get(6).unwrap(), &LoadStatus::Diff(0, 10));
-			assert_eq!(c.get(7).unwrap(), &LoadStatus::Diff(3, 10));
-			assert_eq!(c.get(8).unwrap(), &LoadStatus::Diff(6, 10));
-			assert_eq!(c.get(9).unwrap(), &LoadStatus::Diff(9, 10));
-			assert_eq!(c.get(10).unwrap(), &LoadStatus::DiffComplete);
+			// Since the exact emitted statues are based on time, this matches a dynamic pattern of:
+			// 		- New
+			// 		- QuickDiff(0, 10)
+			// 		- QuickDiff(>0, 10)
+			// 		- CompleteQuickDiff
+			// 		- Diff(0, 10)
+			// 		- Diff(>0, 10)
+			// 		- DiffComplete
+			let mut pass = false;
+			let mut expected = LoadStatus::New;
+			for c in calls.lock().clone() {
+				match (&expected, c) {
+					(&LoadStatus::New, LoadStatus::New) => {
+						expected = LoadStatus::QuickDiff(0, 10);
+					},
+					(&LoadStatus::QuickDiff(0, 10), LoadStatus::QuickDiff(0, 10)) => {
+						expected = LoadStatus::QuickDiff(1, 10);
+					},
+					(&LoadStatus::QuickDiff(1, 10), LoadStatus::QuickDiff(p, 10)) => {
+						assert!(p > 0);
+						expected = LoadStatus::CompleteQuickDiff;
+					},
+					(&LoadStatus::CompleteQuickDiff, LoadStatus::CompleteQuickDiff) => {
+						expected = LoadStatus::Diff(0, 10);
+					},
+					(&LoadStatus::Diff(0, 10), LoadStatus::Diff(0, 10)) => {
+						expected = LoadStatus::Diff(1, 10);
+					},
+					(&LoadStatus::Diff(1, 10), LoadStatus::Diff(p, 10)) => {
+						assert!(p > 0);
+						expected = LoadStatus::DiffComplete;
+					},
+					(&LoadStatus::DiffComplete, LoadStatus::DiffComplete) => {
+						pass = true;
+					},
+					(..) => {},
+				}
+			}
+
+			assert!(pass);
 		});
 	}
 
@@ -922,14 +946,14 @@ mod tests {
 			let notifier = move |status| {
 				let mut c = notifier_calls.lock();
 				c.push(status);
-				return true;
+				true
 			};
 
 			_ = diff_with_notifier(repository, CommitDiffLoaderOptions::new(), notifier).unwrap();
 
 			let c = calls.lock();
 			assert_eq!(c.len(), 1);
-			assert_eq!(c.get(0).unwrap(), &LoadStatus::New);
+			assert_eq!(c.first().unwrap(), &LoadStatus::New);
 		});
 	}
 
@@ -944,14 +968,14 @@ mod tests {
 			let notifier = move |status| {
 				let mut c = notifier_calls.lock();
 				c.push(status);
-				return c.len() == 2;
+				c.len() == 2
 			};
 
 			_ = diff_with_notifier(repository, CommitDiffLoaderOptions::new(), notifier).unwrap();
 
 			let c = calls.lock();
 			assert_eq!(c.len(), 2);
-			assert_eq!(c.get(0).unwrap(), &LoadStatus::New);
+			assert_eq!(c.first().unwrap(), &LoadStatus::New);
 			assert_eq!(c.get(1).unwrap(), &LoadStatus::Diff(0, 1));
 		});
 	}
@@ -969,16 +993,14 @@ mod tests {
 			let notifier = move |status| {
 				let mut c = notifier_calls.lock();
 				c.push(status);
-				return c.len() == 4;
+				c.len() == 4
 			};
 
 			_ = diff_with_notifier(repository, CommitDiffLoaderOptions::new(), notifier).unwrap();
 			let c = calls.lock();
-			assert_eq!(c.len(), 4);
-			assert_eq!(c.get(0).unwrap(), &LoadStatus::New);
+			assert_eq!(c.first().unwrap(), &LoadStatus::New);
 			assert_eq!(c.get(1).unwrap(), &LoadStatus::Diff(0, 10));
-			assert_eq!(c.get(2).unwrap(), &LoadStatus::Diff(3, 10));
-			assert_eq!(c.get(3).unwrap(), &LoadStatus::Diff(6, 10));
+			assert!(matches!(c.last().unwrap(), &LoadStatus::Diff(_, 10)));
 		});
 	}
 
@@ -993,18 +1015,16 @@ mod tests {
 			let calls = Arc::new(Mutex::new(Vec::new()));
 			let notifier_calls = Arc::clone(&calls);
 			let notifier = move |status| {
-				eprintln!("{:?}", status);
 				let mut c = notifier_calls.lock();
 				c.push(status);
-				return c.len() == 3;
+				c.len() == 3
 			};
 
 			_ = diff_with_notifier(repository, CommitDiffLoaderOptions::new().copies(true), notifier).unwrap();
 			let c = calls.lock();
-			assert_eq!(c.len(), 3);
-			assert_eq!(c.get(0).unwrap(), &LoadStatus::New);
+			assert_eq!(c.first().unwrap(), &LoadStatus::New);
 			assert_eq!(c.get(1).unwrap(), &LoadStatus::QuickDiff(0, 10));
-			assert_eq!(c.get(2).unwrap(), &LoadStatus::QuickDiff(3, 10));
+			assert!(matches!(c.last().unwrap(), &LoadStatus::QuickDiff(_, 10)));
 		});
 	}
 
@@ -1020,19 +1040,17 @@ mod tests {
 			let notifier_calls = Arc::clone(&calls);
 			let notifier = move |status| {
 				let mut c = notifier_calls.lock();
+				let rtn = status == LoadStatus::CompleteQuickDiff;
 				c.push(status);
-				return c.len() == 6;
+				rtn
 			};
 
 			_ = diff_with_notifier(repository, CommitDiffLoaderOptions::new().copies(true), notifier).unwrap();
 			let c = calls.lock();
-			assert_eq!(c.len(), 6);
-			assert_eq!(c.get(0).unwrap(), &LoadStatus::New);
+			assert_eq!(c.first().unwrap(), &LoadStatus::New);
 			assert_eq!(c.get(1).unwrap(), &LoadStatus::QuickDiff(0, 10));
-			assert_eq!(c.get(2).unwrap(), &LoadStatus::QuickDiff(3, 10));
-			assert_eq!(c.get(3).unwrap(), &LoadStatus::QuickDiff(6, 10));
-			assert_eq!(c.get(4).unwrap(), &LoadStatus::QuickDiff(9, 10));
-			assert_eq!(c.get(5).unwrap(), &LoadStatus::CompleteQuickDiff);
+			assert!(matches!(c.get(2).unwrap(), &LoadStatus::QuickDiff(_, 10)));
+			assert_eq!(c.last().unwrap(), &LoadStatus::CompleteQuickDiff);
 		});
 	}
 }