✅ Add tests to improve coverage

apps/server/src/utils/auth.rs

@@ -139,6 +139,195 @@ pub fn get_user_and_enforce_permission(
 mod tests {
 	use super::*;
 
+	#[test]
+	fn test_verify_password() {
+		let hash = bcrypt::hash("password", bcrypt::DEFAULT_COST).unwrap();
+		assert!(verify_password(&hash, "password").unwrap());
+	}
+
+	#[test]
+	fn test_get_session_user_no_user() {
+		let session = Session::default();
+		let result = get_session_user(&session);
+		assert!(result.is_err());
+	}
+
+	#[test]
+	fn test_get_session_user_with_user() {
+		let session = Session::default();
+		let session_user = User {
+			username: "oromei".to_string(),
+			..Default::default()
+		};
+		session
+			.insert(SESSION_USER_KEY, session_user.clone())
+			.expect("Failed to insert user into session");
+		let loaded_user = get_session_user(&session).expect("Failed to get session user");
+		assert_eq!(loaded_user.username, session_user.username);
+	}
+
+	#[test]
+	fn test_get_session_server_owner_user_no_user() {
+		let session = Session::default();
+		let result = get_session_server_owner_user(&session);
+		assert!(result.is_err());
+	}
+
+	#[test]
+	fn test_get_session_server_owner_user_with_user() {
+		let session = Session::default();
+		let session_user = User {
+			username: "oromei".to_string(),
+			is_server_owner: true,
+			..Default::default()
+		};
+		session
+			.insert(SESSION_USER_KEY, session_user.clone())
+			.expect("Failed to insert user into session");
+		let loaded_user =
+			get_session_server_owner_user(&session).expect("Failed to get session user");
+		assert_eq!(loaded_user.username, session_user.username);
+	}
+
+	#[test]
+	fn test_enforce_permission_no_user() {
+		let user = User::default();
+		let result = enforce_permission(&user, UserPermission::CreateLibrary);
+		assert!(result.is_err());
+	}
+
+	#[test]
+	fn test_enforce_permission_no_permission() {
+		let user = User::default();
+		let result = enforce_permission(&user, UserPermission::CreateLibrary);
+		assert!(result.is_err());
+	}
+
+	#[test]
+	fn test_enforce_permission_with_permission() {
+		let user = User {
+			permissions: vec![UserPermission::CreateLibrary],
+			..Default::default()
+		};
+		let result = enforce_permission(&user, UserPermission::CreateLibrary);
+		assert!(result.is_ok());
+	}
+
+	#[test]
+	fn test_enforce_permission_as_server_owner() {
+		let user = User {
+			is_server_owner: true,
+			..Default::default()
+		};
+		let result = enforce_permission(&user, UserPermission::CreateLibrary);
+		assert!(result.is_ok());
+	}
+
+	#[test]
+	fn test_enforce_session_permissions_no_user() {
+		let session = Session::default();
+		let result =
+			enforce_session_permissions(&session, &[UserPermission::CreateLibrary]);
+		assert!(result.is_err());
+	}
+
+	#[test]
+	fn test_enforce_session_permissions_no_permission() {
+		let session = Session::default();
+		let session_user = User::default();
+		session
+			.insert(SESSION_USER_KEY, session_user.clone())
+			.expect("Failed to insert user into session");
+		let result =
+			enforce_session_permissions(&session, &[UserPermission::CreateLibrary]);
+		assert!(result.is_err());
+	}
+
+	#[test]
+	fn test_enforce_session_permissions_with_partial_permission() {
+		let session = Session::default();
+		let session_user = User {
+			permissions: vec![UserPermission::CreateLibrary],
+			..Default::default()
+		};
+		session
+			.insert(SESSION_USER_KEY, session_user.clone())
+			.expect("Failed to insert user into session");
+		let result = enforce_session_permissions(
+			&session,
+			&[
+				UserPermission::CreateLibrary,
+				UserPermission::AccessBookClub, // This permission is not granted to user, so expect failure
+			],
+		);
+		assert!(result.is_err());
+	}
+
+	#[test]
+	fn test_enforce_session_permissions_with_all_permission() {
+		let session = Session::default();
+		let session_user = User {
+			permissions: vec![UserPermission::CreateLibrary],
+			..Default::default()
+		};
+		session
+			.insert(SESSION_USER_KEY, session_user.clone())
+			.expect("Failed to insert user into session");
+		let result =
+			enforce_session_permissions(&session, &[UserPermission::CreateLibrary]);
+		assert!(result.is_ok());
+	}
+
+	#[test]
+	fn test_enforce_session_permissions_as_server_owner() {
+		let session = Session::default();
+		let session_user = User {
+			is_server_owner: true,
+			..Default::default()
+		};
+		session
+			.insert(SESSION_USER_KEY, session_user.clone())
+			.expect("Failed to insert user into session");
+		let result = enforce_session_permissions(
+			&session,
+			&[
+				UserPermission::CreateLibrary,
+				UserPermission::AccessBookClub, // This permission is not granted to user, so expect failure
+			],
+		);
+		assert!(result.is_ok());
+	}
+
+	#[test]
+	fn test_decode_64_credentials_with_colon_in_password() {
+		let testcreds = decode_base64_credentials("username:pass:$%^word".into());
+		assert_eq!(testcreds.unwrap().password, String::from("pass:$%^word"));
+	}
+
+	#[test]
+	fn test_decode_64_credentials_32_chars_password() {
+		let testcreds =
+			decode_base64_credentials("username:wp*r@hj!1b:o4sZ#5TdvyzBd$n-bqaPi".into());
+		assert_eq!(
+			testcreds.unwrap().password,
+			String::from("wp*r@hj!1b:o4sZ#5TdvyzBd$n-bqaPi")
+		);
+	}
+
+	#[test]
+	fn test_decode_64_credentials_64_chars_password() {
+		let testcreds = decode_base64_credentials(
+			"username:wp*r@hj!1b:o4sZ#5TdvyzBd$n-bqaPiwp*r@hj!1b:o4sZ#5TdvyzBd$n-bqaPi"
+				.into(),
+		);
+		assert_eq!(
+			testcreds.unwrap().password,
+			String::from(
+				"wp*r@hj!1b:o4sZ#5TdvyzBd$n-bqaPiwp*r@hj!1b:o4sZ#5TdvyzBd$n-bqaPi"
+			)
+		);
+	}
+
 	#[test]
 	fn test_associated_permissions() {
 		let user = User {
@@ -159,10 +348,4 @@ mod tests {
 
 		assert!(user_has_all_permissions(&user, &expected_can_do));
 	}
-
-	#[test]
-	fn test_password_parsing() {
-		let testcreds = decode_base64_credentials("username:pass:$%^word".into());
-		assert_eq!(testcreds.unwrap().password, String::from("pass:$%^word"));
-	}
 }

apps/server/src/utils/date.rs

@@ -16,3 +16,36 @@ pub fn safe_string_to_date(date: String) -> DateTime<Utc> {
 		Utc::now()
 	})
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+
+	#[test]
+	fn test_string_to_date() {
+		let date = "2021-01-01T00:00:00Z".to_string();
+		let result = string_to_date(date);
+		assert!(result.is_ok());
+	}
+
+	#[test]
+	fn test_string_to_date_invalid() {
+		let date = "2021-01-01T00:00:00".to_string();
+		let result = string_to_date(date);
+		assert!(result.is_err());
+	}
+
+	#[test]
+	fn test_safe_string_to_date() {
+		let date = "2021-01-01T00:00:00Z".to_string();
+		let result = safe_string_to_date(date);
+		assert!(result.timestamp() > 0);
+	}
+
+	#[test]
+	fn test_safe_string_to_date_invalid() {
+		let date = "2021-01-01T00:00:00".to_string();
+		let result = safe_string_to_date(date);
+		assert!(result.timestamp() > 0);
+	}
+}

apps/server/src/utils/http.rs

@@ -187,3 +187,78 @@ impl IntoResponse for NamedFile {
 			.unwrap_or_else(|e| unexpected_error(e).into_response())
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use stump_core::filesystem::ContentType;
+
+	#[test]
+	fn test_buffer_response() {
+		let response = BufferResponse::new(ContentType::HTML, b"Hello, world!".to_vec());
+		let axum_response = response.into_response();
+
+		assert_eq!(
+			axum_response.headers().get(header::CONTENT_TYPE),
+			Some(&HeaderValue::from_static("text/html"))
+		);
+	}
+
+	#[test]
+	fn test_image_response() {
+		let response = ImageResponse::new(ContentType::JPEG, b"Hello, world!".to_vec());
+		let axum_response = response.into_response();
+
+		assert_eq!(
+			axum_response.headers().get(header::CONTENT_TYPE),
+			Some(&HeaderValue::from_static("image/jpeg"))
+		);
+	}
+
+	#[test]
+	fn test_xml_response() {
+		let response = Xml("<xml></xml>".to_string());
+		let axum_response = response.into_response();
+
+		assert_eq!(
+			axum_response.headers().get(header::CONTENT_TYPE),
+			Some(&HeaderValue::from_static("application/xml"))
+		);
+	}
+
+	#[test]
+	fn test_unknown_buffer_response() {
+		let response = UnknownBufferResponse {
+			content_type: "application/json".to_string(),
+			data: b"Hello, world!".to_vec(),
+		};
+		let axum_response = response.into_response();
+
+		assert_eq!(
+			axum_response.headers().get(header::CONTENT_TYPE),
+			Some(&HeaderValue::from_static("application/json"))
+		);
+	}
+
+	#[tokio::test]
+	async fn test_named_file_response() {
+		let response = NamedFile::open(
+			PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+				.join("../../core/integration-tests/data/example.jpeg"),
+		)
+		.await
+		.unwrap();
+		let axum_response = response.into_response();
+
+		assert_eq!(
+			axum_response.headers().get(header::CONTENT_TYPE),
+			Some(&HeaderValue::from_static("image/jpeg"))
+		);
+		assert_eq!(
+			axum_response.headers().get(header::CONTENT_DISPOSITION),
+			Some(&HeaderValue::from_static(
+				"attachment; filename=\"example.jpeg\""
+			))
+		);
+	}
+}