chore: fix tests, add coverage

bitfl0wer · bitfl0wer · commit aa59ed6d554c · 2025-07-18T20:49:18.000+02:00
diff --git a/fixtures/tokens_base_fixture.sql b/fixtures/tokens_base_fixture.sql
@@ -31,11 +31,6 @@ INSERT INTO public_keys (id, uaid, pubkey, algorithm_identifier) VALUES
 (5, '00000000-0000-0000-0000-000000000001', 'test_pubkey_1_b', 1),
 (6, '00000000-0000-0000-0000-000000000004', 'test_pubkey_4_b', 1);
 
--- Test issuers
-INSERT INTO issuers (id, domain_components, pem_encoded) VALUES
-(1, ARRAY['example', 'com'], 'test_issuer_pem_1'),
-(2, ARRAY['test', 'org'], 'test_issuer_pem_2');
-
 -- Test ID-CSRs (for all test users)
 INSERT INTO idcsr (
     id, serial_number, uaid, actor_public_key_id, actor_signature,
@@ -50,6 +45,11 @@ INSERT INTO idcsr (
 -- Additional ID-CSR with unique serial number for user 4 (for testing expired tokens)
 (6, 55555555555555555556, '00000000-0000-0000-0000-000000000004', 6, 'test_signature_4_b', 'test_session_4_b', NOW() - INTERVAL '1 day', NOW() + INTERVAL '1 day', 'test_extensions_4_b', 'test_csr_pem_4_b');
 
+-- Test issuers (must be inserted after idcsr because of foreign key constraint)
+INSERT INTO issuers (id, domain_components, pem_encoded) VALUES
+(1, ARRAY['example', 'com'], 'test_csr_pem_1'),
+(2, ARRAY['test', 'org'], 'test_csr_pem_2');
+
 -- Test ID-Certs
 -- User 1 and 2 have certificates (for basic scenarios)
 -- User 4 has a certificate (for extended scenarios)
diff --git a/src/api/admin/db/mod.rs b/src/api/admin/db/mod.rs
@@ -11,6 +11,7 @@ use crate::{
 };
 
 /// Create an invite.
+#[cfg_attr(coverage_nightly, coverage(off))]
 pub(super) async fn create_invite(
 	owner: Option<&Uuid>,
 	code: Option<&str>,
diff --git a/src/api/auth/login.rs b/src/api/auth/login.rs
@@ -15,6 +15,7 @@ use crate::{
 };
 
 #[handler]
+#[cfg_attr(coverage_nightly, coverage(off))]
 pub(super) async fn login(
 	Json(payload): Json<LoginSchema>,
 	Data(db): Data<&Database>,
diff --git a/src/api/auth/register.rs b/src/api/auth/register.rs
@@ -16,8 +16,8 @@ use crate::{
 	errors::{Context, Errcode, Error},
 };
 
-#[cfg_attr(coverage_nightly, coverage(off))]
 #[handler]
+#[cfg_attr(coverage_nightly, coverage(off))]
 pub(super) async fn register(
 	Json(payload): Json<RegisterSchema>,
 	Data(db): Data<&Database>,
diff --git a/src/api/mod.rs b/src/api/mod.rs
@@ -4,20 +4,15 @@
 
 use log::info;
 use poem::{
-	EndpointExt, IntoResponse, Response, Route, Server,
-	error::ResponseError,
-	handler,
+	EndpointExt, IntoResponse, Response, Route, Server, handler,
 	http::{Method, StatusCode},
 	listener::TcpListener,
 	middleware::{Cors, NormalizePath},
-	web::Json,
 };
-use serde_json::json;
 
 use crate::{
 	config::ApiConfig,
 	database::{Database, tokens::TokenStore},
-	errors::Error,
 };
 
 /// Admin-only functionality.
diff --git a/src/crypto/ed25519/private_key.rs b/src/crypto/ed25519/private_key.rs
@@ -9,6 +9,7 @@ pub(crate) struct DigitalPrivateKey {
 	pubkey: DigitalPublicKey,
 }
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl PrivateKey<DigitalSignature> for DigitalPrivateKey {
 	type PublicKey = DigitalPublicKey;
 
diff --git a/src/crypto/ed25519/public_key.rs b/src/crypto/ed25519/public_key.rs
@@ -8,6 +8,7 @@ pub(crate) struct DigitalPublicKey {
 	key: VerifyingKey,
 }
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl PublicKey<DigitalSignature> for DigitalPublicKey {
 	fn verify_signature(
 		&self,
@@ -39,6 +40,7 @@ impl PublicKey<DigitalSignature> for DigitalPublicKey {
 		}
 	}
 
+	#[cfg_attr(coverage_nightly, coverage(off))]
 	fn try_from_public_key_info(
 		public_key_info: polyproto::certs::PublicKeyInfo,
 	) -> Result<Self, polyproto::errors::CertificateConversionError> {
diff --git a/src/crypto/ed25519/signature.rs b/src/crypto/ed25519/signature.rs
@@ -15,18 +15,21 @@ pub(crate) struct DigitalSignature {
 	pub(super) signature: ed25519_dalek::Signature,
 }
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl SignatureBitStringEncoding for DigitalSignature {
 	fn to_bitstring(&self) -> polyproto::der::Result<BitString> {
 		BitString::from_bytes(&self.as_signature().to_bytes())
 	}
 }
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl std::fmt::Display for DigitalSignature {
 	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
 		f.write_str(&self.signature.to_string())
 	}
 }
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl SignatureTrait for DigitalSignature {
 	type Signature = ed25519_dalek::Signature;
 
diff --git a/src/database/algorithm_identifier.rs b/src/database/algorithm_identifier.rs
@@ -13,6 +13,7 @@ pub(crate) struct AlgorithmIdentifier {
 	pub(crate) parameters: Option<String>,
 }
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl AlgorithmIdentifier {
 	/// Tries to find an entry or entries from the `algorithm_identifiers` table
 	/// matching the given parameter(s). The more parameters given, the more
diff --git a/src/database/issuer.rs b/src/database/issuer.rs
@@ -14,6 +14,7 @@ pub(crate) struct Issuer {
 	pub(crate) id_cert: IdCert<DigitalSignature, DigitalPublicKey>,
 }
 
+#[cfg_attr(coverage_nightly, coverage(off))]
 impl Issuer {
 	/// Create (insert) the issuer entry for this sonata instance. Returns
 	/// `None`, if there is already a valid issuer entry for the given point in
diff --git a/src/errors.rs b/src/errors.rs
@@ -247,4 +247,173 @@ mod tests {
 		assert_eq!(ctx.expected, "expected");
 		assert_eq!(ctx.message, "message");
 	}
+
+	#[test]
+	fn test_error_without_context() {
+		let error = Error::new(Errcode::Internal, None);
+
+		assert_eq!(error.code, Errcode::Internal);
+		assert_eq!(
+			error.message,
+			"An internal error has occurred and this request cannot be processed further"
+		);
+		assert!(error.context.is_none());
+	}
+
+	#[test]
+	fn test_error_to_json() {
+		let context = Context::new(Some("username"), Some("admin"), Some("valid username"), None);
+		let error = Error::new(Errcode::Duplicate, Some(context));
+
+		let json = error.to_json();
+		assert!(json.contains("P2_CORE_DUPLICATE"));
+		assert!(json.contains("username"));
+		assert!(json.contains("admin"));
+		assert!(json.contains("valid username"));
+	}
+
+	#[test]
+	fn test_error_new_invalid_login() {
+		let error = Error::new_invalid_login();
+
+		assert_eq!(error.code, Errcode::Unauthorized);
+		assert_eq!(
+			error.message,
+			"This action requires authorization, proof of which was not granted"
+		);
+		assert!(error.context.is_some());
+		let ctx = error.context.unwrap();
+		assert_eq!(ctx.message, ERROR_WRONG_LOGIN);
+	}
+
+	#[test]
+	fn test_error_new_internal_error() {
+		let error = Error::new_internal_error(Some("Database connection failed"));
+
+		assert_eq!(error.code, Errcode::Internal);
+		assert!(error.context.is_some());
+		let ctx = error.context.unwrap();
+		assert_eq!(ctx.message, "Database connection failed");
+	}
+
+	#[test]
+	fn test_error_new_duplicate_error() {
+		let error = Error::new_duplicate_error(Some("User already exists"));
+
+		assert_eq!(error.code, Errcode::Duplicate);
+		assert!(error.context.is_some());
+		let ctx = error.context.unwrap();
+		assert_eq!(ctx.message, "User already exists");
+	}
+
+	#[test]
+	fn test_errcode_messages() {
+		assert_eq!(
+			Errcode::Internal.message(),
+			"An internal error has occurred and this request cannot be processed further"
+		);
+		assert_eq!(
+			Errcode::Unauthorized.message(),
+			"This action requires authorization, proof of which was not granted"
+		);
+		assert_eq!(
+			Errcode::Duplicate.message(),
+			"Creation of the resource is not possible, as it already exists"
+		);
+		assert_eq!(
+			Errcode::IllegalInput.message(),
+			"The overall input is well-formed, but one or more of the input fields fail validation criteria"
+		);
+	}
+
+	#[test]
+	fn test_errcode_status_codes() {
+		use poem::http::StatusCode;
+
+		assert_eq!(Errcode::Internal.status(), StatusCode::INTERNAL_SERVER_ERROR);
+		assert_eq!(Errcode::Unauthorized.status(), StatusCode::UNAUTHORIZED);
+		assert_eq!(Errcode::Duplicate.status(), StatusCode::CONFLICT);
+		assert_eq!(Errcode::IllegalInput.status(), StatusCode::BAD_REQUEST);
+	}
+
+	#[test]
+	fn test_errcode_serialization() {
+		let internal = Errcode::Internal;
+		let serialized = serde_json::to_string(&internal).unwrap();
+		assert_eq!(serialized, "\"P2_CORE_INTERNAL\"");
+
+		let deserialized: Errcode = serde_json::from_str(&serialized).unwrap();
+		assert_eq!(deserialized, Errcode::Internal);
+	}
+
+	#[test]
+	fn test_context_new() {
+		let context =
+			Context::new(Some("password"), Some("weak"), Some("strong"), Some("Password too weak"));
+
+		assert_eq!(context.field_name, "password");
+		assert_eq!(context.found, "weak");
+		assert_eq!(context.expected, "strong");
+		assert_eq!(context.message, "Password too weak");
+	}
+
+	#[test]
+	fn test_context_new_with_none_values() {
+		let context = Context::new(None, None, None, Some("General error"));
+
+		assert!(context.field_name.is_empty());
+		assert!(context.found.is_empty());
+		assert!(context.expected.is_empty());
+		assert_eq!(context.message, "General error");
+	}
+
+	#[test]
+	fn test_error_into_response() {
+		let error = Error::new(Errcode::IllegalInput, None);
+		let response = error.into_response();
+
+		assert_eq!(response.status(), poem::http::StatusCode::BAD_REQUEST);
+		assert_eq!(response.headers().get("content-type").unwrap(), "application/json");
+	}
+
+	#[test]
+	fn test_error_from_sqlx_error() {
+		use sqlx::Error as SqlxError;
+
+		let sqlx_error = SqlxError::RowNotFound;
+		let error: Error = sqlx_error.into();
+
+		assert_eq!(error.code, Errcode::Internal);
+		assert!(error.context.is_none());
+	}
+
+	#[test]
+	fn test_error_into_poem_error() {
+		let error = Error::new(Errcode::Unauthorized, None);
+		let poem_error: poem::Error = error.into();
+
+		// We can't directly test the poem::Error contents, but we can ensure the
+		// conversion works
+		assert_eq!(poem_error.status(), poem::http::StatusCode::UNAUTHORIZED);
+	}
+
+	#[test]
+	fn test_errcode_display() {
+		assert_eq!(Errcode::Internal.to_string(), "P2_CORE_INTERNAL");
+		assert_eq!(Errcode::Unauthorized.to_string(), "P2_CORE_UNAUTHORIZED");
+		assert_eq!(Errcode::Duplicate.to_string(), "P2_CORE_DUPLICATE");
+		assert_eq!(Errcode::IllegalInput.to_string(), "P2_CORE_ILLEGAL_INPUT");
+	}
+
+	#[test]
+	fn test_errcode_from_str() {
+		use std::str::FromStr;
+
+		assert_eq!(Errcode::from_str("P2_CORE_INTERNAL").unwrap(), Errcode::Internal);
+		assert_eq!(Errcode::from_str("P2_CORE_UNAUTHORIZED").unwrap(), Errcode::Unauthorized);
+		assert_eq!(Errcode::from_str("P2_CORE_DUPLICATE").unwrap(), Errcode::Duplicate);
+		assert_eq!(Errcode::from_str("P2_CORE_ILLEGAL_INPUT").unwrap(), Errcode::IllegalInput);
+
+		assert!(Errcode::from_str("INVALID_CODE").is_err());
+	}
 }

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ pub(crate) struct DigitalPrivateKey {`
`9`	`9`	`pubkey: DigitalPublicKey,`
`10`	`10`	`}`
`11`	`11`
	`12`	`+#[cfg_attr(coverage_nightly, coverage(off))]`
`12`	`13`	`impl PrivateKey<DigitalSignature> for DigitalPrivateKey {`
`13`	`14`	`type PublicKey = DigitalPublicKey;`
`14`	`15`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@ pub(crate) struct DigitalPublicKey {`
`8`	`8`	`key: VerifyingKey,`
`9`	`9`	`}`
`10`	`10`
	`11`	`+#[cfg_attr(coverage_nightly, coverage(off))]`
`11`	`12`	`impl PublicKey<DigitalSignature> for DigitalPublicKey {`
`12`	`13`	`fn verify_signature(`
`13`	`14`	`&self,`
`@@ -39,6 +40,7 @@ impl PublicKey<DigitalSignature> for DigitalPublicKey {`
`39`	`40`	`}`
`40`	`41`	`}`
`41`	`42`
	`43`	`+ #[cfg_attr(coverage_nightly, coverage(off))]`
`42`	`44`	`fn try_from_public_key_info(`
`43`	`45`	`public_key_info: polyproto::certs::PublicKeyInfo,`
`44`	`46`	`) -> Result<Self, polyproto::errors::CertificateConversionError> {`
Original file line number	Diff line number	Diff line change
`@@ -15,18 +15,21 @@ pub(crate) struct DigitalSignature {`
`15`	`15`	`pub(super) signature: ed25519_dalek::Signature,`
`16`	`16`	`}`
`17`	`17`
	`18`	`+#[cfg_attr(coverage_nightly, coverage(off))]`
`18`	`19`	`impl SignatureBitStringEncoding for DigitalSignature {`
`19`	`20`	`fn to_bitstring(&self) -> polyproto::der::Result<BitString> {`
`20`	`21`	`BitString::from_bytes(&self.as_signature().to_bytes())`
`21`	`22`	`}`
`22`	`23`	`}`
`23`	`24`
	`25`	`+#[cfg_attr(coverage_nightly, coverage(off))]`
`24`	`26`	`impl std::fmt::Display for DigitalSignature {`
`25`	`27`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`26`	`28`	`f.write_str(&self.signature.to_string())`
`27`	`29`	`}`
`28`	`30`	`}`
`29`	`31`
	`32`	`+#[cfg_attr(coverage_nightly, coverage(off))]`
`30`	`33`	`impl SignatureTrait for DigitalSignature {`
`31`	`34`	`type Signature = ed25519_dalek::Signature;`
`32`	`35`
Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@ pub(crate) struct AlgorithmIdentifier {`
`13`	`13`	`pub(crate) parameters: Option<String>,`
`14`	`14`	`}`
`15`	`15`
	`16`	`+#[cfg_attr(coverage_nightly, coverage(off))]`
`16`	`17`	`impl AlgorithmIdentifier {`
`17`	`18`	/// Tries to find an entry or entries from the `algorithm_identifiers` table
`18`	`19`	`/// matching the given parameter(s). The more parameters given, the more`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@ pub(crate) struct Issuer {`
`14`	`14`	`pub(crate) id_cert: IdCert<DigitalSignature, DigitalPublicKey>,`
`15`	`15`	`}`
`16`	`16`
	`17`	`+#[cfg_attr(coverage_nightly, coverage(off))]`
`17`	`18`	`impl Issuer {`
`18`	`19`	`/// Create (insert) the issuer entry for this sonata instance. Returns`
`19`	`20`	/// `None`, if there is already a valid issuer entry for the given point in