test: write assertions for error logs in the API

These tests produce expected errors in the logs:

```
servers::api::v1::contract::authentication::should_not_authenticate_requests_when_the_token_is_empty
servers::api::v1::contract::authentication::should_not_authenticate_requests_when_the_token_is_invalid
servers::api::v1::contract::authentication::should_not_authenticate_requests_when_the_token_is_missing
servers::api::v1::contract::context::auth_key::deprecated_generate_key_endpoint::should_fail_when_the_auth_key_cannot_be_generated
servers::api::v1::contract::context::auth_key::deprecated_generate_key_endpoint::should_not_allow_generating_a_new_auth_key_for_unauthenticated_users
servers::api::v1::contract::context::auth_key::should_fail_when_keys_cannot_be_reloaded
servers::api::v1::contract::context::auth_key::should_fail_when_the_auth_key_cannot_be_deleted
servers::api::v1::contract::context::auth_key::should_fail_when_the_auth_key_cannot_be_generated
servers::api::v1::contract::context::auth_key::should_not_allow_deleting_an_auth_key_for_unauthenticated_users
servers::api::v1::contract::context::auth_key::should_not_allow_generating_a_new_auth_key_for_unauthenticated_users
servers::api::v1::contract::context::auth_key::should_not_allow_reloading_keys_for_unauthenticated_users
servers::api::v1::contract::context::stats::should_not_allow_getting_tracker_statistics_for_unauthenticated_users
servers::api::v1::contract::context::torrent::should_not_allow_getting_a_torrent_info_for_unauthenticated_users
servers::api::v1::contract::context::torrent::should_not_allow_getting_torrents_for_unauthenticated_users
servers::api::v1::contract::context::whitelist::should_fail_when_the_torrent_cannot_be_removed_from_the_whitelist
servers::api::v1::contract::context::whitelist::should_fail_when_the_whitelist_cannot_be_reloaded_from_the_database
servers::api::v1::contract::context::whitelist::should_not_allow_removing_a_torrent_from_the_whitelist_for_unauthenticated_users
```

This change adds assertions for triggered errors in logs.

Author: josecelano

tests/servers/api/v1/contract/authentication.rs

@@ -1,6 +1,8 @@
 use torrust_tracker_test_helpers::configuration;
+use tracing::level_filters::LevelFilter;
 
 use crate::common::http::{Query, QueryParam};
+use crate::common::logging::{self, logs_contains_a_line_with};
 use crate::servers::api::v1::asserts::{assert_token_not_valid, assert_unauthorized};
 use crate::servers::api::v1::client::Client;
 use crate::servers::api::Started;
@@ -22,6 +24,8 @@ async fn should_authenticate_requests_by_using_a_token_query_param() {
 
 #[tokio::test]
 async fn should_not_authenticate_requests_when_the_token_is_missing() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let response = Client::new(env.get_connection_info())
@@ -31,10 +35,14 @@ async fn should_not_authenticate_requests_when_the_token_is_missing() {
     assert_unauthorized(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 #[tokio::test]
 async fn should_not_authenticate_requests_when_the_token_is_empty() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let response = Client::new(env.get_connection_info())
@@ -44,10 +52,14 @@ async fn should_not_authenticate_requests_when_the_token_is_empty() {
     assert_token_not_valid(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 #[tokio::test]
 async fn should_not_authenticate_requests_when_the_token_is_invalid() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let response = Client::new(env.get_connection_info())
@@ -57,6 +69,8 @@ async fn should_not_authenticate_requests_when_the_token_is_invalid() {
     assert_token_not_valid(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 #[tokio::test]

tests/servers/api/v1/contract/context/auth_key.rs

@@ -61,6 +61,8 @@ async fn should_allow_uploading_a_preexisting_auth_key() {
 
 #[tokio::test]
 async fn should_not_allow_generating_a_new_auth_key_for_unauthenticated_users() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let response = Client::new(connection_with_invalid_token(env.get_connection_info().bind_address.as_str()))
@@ -82,10 +84,14 @@ async fn should_not_allow_generating_a_new_auth_key_for_unauthenticated_users()
     assert_unauthorized(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 #[tokio::test]
 async fn should_fail_when_the_auth_key_cannot_be_generated() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     force_database_error(&env.tracker);
@@ -100,6 +106,8 @@ async fn should_fail_when_the_auth_key_cannot_be_generated() {
     assert_failed_to_generate_key(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 #[tokio::test]
@@ -237,13 +245,15 @@ async fn should_fail_when_the_auth_key_cannot_be_deleted() {
 
     assert_failed_to_delete_key(response).await;
 
-    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
-
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 #[tokio::test]
 async fn should_not_allow_deleting_an_auth_key_for_unauthenticated_users() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let seconds_valid = 60;
@@ -275,6 +285,8 @@ async fn should_not_allow_deleting_an_auth_key_for_unauthenticated_users() {
     assert_unauthorized(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 #[tokio::test]
@@ -296,6 +308,8 @@ async fn should_allow_reloading_keys() {
 
 #[tokio::test]
 async fn should_fail_when_keys_cannot_be_reloaded() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let seconds_valid = 60;
@@ -311,10 +325,14 @@ async fn should_fail_when_keys_cannot_be_reloaded() {
     assert_failed_to_reload_keys(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 #[tokio::test]
 async fn should_not_allow_reloading_keys_for_unauthenticated_users() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let seconds_valid = 60;
@@ -336,13 +354,17 @@ async fn should_not_allow_reloading_keys_for_unauthenticated_users() {
     assert_unauthorized(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 mod deprecated_generate_key_endpoint {
 
     use torrust_tracker::core::auth::Key;
     use torrust_tracker_test_helpers::configuration;
+    use tracing::level_filters::LevelFilter;
 
+    use crate::common::logging::{self, logs_contains_a_line_with};
     use crate::servers::api::connection_info::{connection_with_invalid_token, connection_with_no_token};
     use crate::servers::api::v1::asserts::{
         assert_auth_key_utf8, assert_failed_to_generate_key, assert_invalid_key_duration_param, assert_token_not_valid,
@@ -372,6 +394,8 @@ mod deprecated_generate_key_endpoint {
 
     #[tokio::test]
     async fn should_not_allow_generating_a_new_auth_key_for_unauthenticated_users() {
+        logging::setup(LevelFilter::ERROR);
+
         let env = Started::new(&configuration::ephemeral().into()).await;
 
         let seconds_valid = 60;
@@ -389,6 +413,8 @@ mod deprecated_generate_key_endpoint {
         assert_unauthorized(response).await;
 
         env.stop().await;
+
+        assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
     }
 
     #[tokio::test]
@@ -414,6 +440,8 @@ mod deprecated_generate_key_endpoint {
 
     #[tokio::test]
     async fn should_fail_when_the_auth_key_cannot_be_generated() {
+        logging::setup(LevelFilter::ERROR);
+
         let env = Started::new(&configuration::ephemeral().into()).await;
 
         force_database_error(&env.tracker);
@@ -424,5 +452,7 @@ mod deprecated_generate_key_endpoint {
         assert_failed_to_generate_key(response).await;
 
         env.stop().await;
+
+        assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
     }
 }

tests/servers/api/v1/contract/context/stats.rs

@@ -4,7 +4,9 @@ use bittorrent_primitives::info_hash::InfoHash;
 use torrust_tracker::servers::apis::v1::context::stats::resources::Stats;
 use torrust_tracker_primitives::peer::fixture::PeerBuilder;
 use torrust_tracker_test_helpers::configuration;
+use tracing::level_filters::LevelFilter;
 
+use crate::common::logging::{self, logs_contains_a_line_with};
 use crate::servers::api::connection_info::{connection_with_invalid_token, connection_with_no_token};
 use crate::servers::api::v1::asserts::{assert_stats, assert_token_not_valid, assert_unauthorized};
 use crate::servers::api::v1::client::Client;
@@ -58,6 +60,8 @@ async fn should_allow_getting_tracker_statistics() {
 
 #[tokio::test]
 async fn should_not_allow_getting_tracker_statistics_for_unauthenticated_users() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let response = Client::new(connection_with_invalid_token(env.get_connection_info().bind_address.as_str()))
@@ -73,4 +77,6 @@ async fn should_not_allow_getting_tracker_statistics_for_unauthenticated_users()
     assert_unauthorized(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }

tests/servers/api/v1/contract/context/torrent.rs

@@ -5,8 +5,10 @@ use torrust_tracker::servers::apis::v1::context::torrent::resources::peer::Peer;
 use torrust_tracker::servers::apis::v1::context::torrent::resources::torrent::{self, Torrent};
 use torrust_tracker_primitives::peer::fixture::PeerBuilder;
 use torrust_tracker_test_helpers::configuration;
+use tracing::level_filters::LevelFilter;
 
 use crate::common::http::{Query, QueryParam};
+use crate::common::logging::{self, logs_contains_a_line_with};
 use crate::servers::api::connection_info::{connection_with_invalid_token, connection_with_no_token};
 use crate::servers::api::v1::asserts::{
     assert_bad_request, assert_invalid_infohash_param, assert_not_found, assert_token_not_valid, assert_torrent_info,
@@ -199,6 +201,8 @@ async fn should_fail_getting_torrents_when_the_info_hash_parameter_is_invalid()
 
 #[tokio::test]
 async fn should_not_allow_getting_torrents_for_unauthenticated_users() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let response = Client::new(connection_with_invalid_token(env.get_connection_info().bind_address.as_str()))
@@ -214,6 +218,8 @@ async fn should_not_allow_getting_torrents_for_unauthenticated_users() {
     assert_unauthorized(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 #[tokio::test]
@@ -281,6 +287,8 @@ async fn should_fail_getting_a_torrent_info_when_the_provided_infohash_is_invali
 
 #[tokio::test]
 async fn should_not_allow_getting_a_torrent_info_for_unauthenticated_users() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let info_hash = InfoHash::from_str("9e0217d0fa71c87332cd8bf9dbeabcb2c2cf3c4d").unwrap();
@@ -300,4 +308,6 @@ async fn should_not_allow_getting_a_torrent_info_for_unauthenticated_users() {
     assert_unauthorized(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }

tests/servers/api/v1/contract/context/whitelist.rs

@@ -2,7 +2,9 @@ use std::str::FromStr;
 
 use bittorrent_primitives::info_hash::InfoHash;
 use torrust_tracker_test_helpers::configuration;
+use tracing::level_filters::LevelFilter;
 
+use crate::common::logging::{self, logs_contains_a_line_with};
 use crate::servers::api::connection_info::{connection_with_invalid_token, connection_with_no_token};
 use crate::servers::api::v1::asserts::{
     assert_failed_to_reload_whitelist, assert_failed_to_remove_torrent_from_whitelist, assert_failed_to_whitelist_torrent,
@@ -51,6 +53,8 @@ async fn should_allow_whitelisting_a_torrent_that_has_been_already_whitelisted()
 
 #[tokio::test]
 async fn should_not_allow_whitelisting_a_torrent_for_unauthenticated_users() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let info_hash = "9e0217d0fa71c87332cd8bf9dbeabcb2c2cf3c4d".to_owned();
@@ -68,6 +72,8 @@ async fn should_not_allow_whitelisting_a_torrent_for_unauthenticated_users() {
     assert_unauthorized(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 #[tokio::test]
@@ -166,6 +172,8 @@ async fn should_fail_removing_a_torrent_from_the_whitelist_when_the_provided_inf
 
 #[tokio::test]
 async fn should_fail_when_the_torrent_cannot_be_removed_from_the_whitelist() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let hash = "9e0217d0fa71c87332cd8bf9dbeabcb2c2cf3c4d".to_owned();
@@ -181,10 +189,14 @@ async fn should_fail_when_the_torrent_cannot_be_removed_from_the_whitelist() {
     assert_failed_to_remove_torrent_from_whitelist(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 #[tokio::test]
 async fn should_not_allow_removing_a_torrent_from_the_whitelist_for_unauthenticated_users() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let hash = "9e0217d0fa71c87332cd8bf9dbeabcb2c2cf3c4d".to_owned();
@@ -205,6 +217,8 @@ async fn should_not_allow_removing_a_torrent_from_the_whitelist_for_unauthentica
     assert_unauthorized(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }
 
 #[tokio::test]
@@ -234,6 +248,8 @@ async fn should_allow_reload_the_whitelist_from_the_database() {
 
 #[tokio::test]
 async fn should_fail_when_the_whitelist_cannot_be_reloaded_from_the_database() {
+    logging::setup(LevelFilter::ERROR);
+
     let env = Started::new(&configuration::ephemeral().into()).await;
 
     let hash = "9e0217d0fa71c87332cd8bf9dbeabcb2c2cf3c4d".to_owned();
@@ -247,4 +263,6 @@ async fn should_fail_when_the_whitelist_cannot_be_reloaded_from_the_database() {
     assert_failed_to_reload_whitelist(response).await;
 
     env.stop().await;
+
+    assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
 }

tests/servers/http/v1/contract.rs

@@ -1126,14 +1126,18 @@ mod configured_as_whitelisted {
 
         use bittorrent_primitives::info_hash::InfoHash;
         use torrust_tracker_test_helpers::configuration;
+        use tracing::level_filters::LevelFilter;
 
+        use crate::common::logging::{self, logs_contains_a_line_with};
         use crate::servers::http::asserts::{assert_is_announce_response, assert_torrent_not_in_whitelist_error_response};
         use crate::servers::http::client::Client;
         use crate::servers::http::requests::announce::QueryBuilder;
         use crate::servers::http::Started;
 
         #[tokio::test]
         async fn should_fail_if_the_torrent_is_not_in_the_whitelist() {
+            logging::setup(LevelFilter::ERROR);
+
             let env = Started::new(&configuration::ephemeral_listed().into()).await;
 
             let info_hash = InfoHash::from_str("9c38422213e30bff212b30c360d26f9a02136422").unwrap();
@@ -1145,6 +1149,8 @@ mod configured_as_whitelisted {
             assert_torrent_not_in_whitelist_error_response(response).await;
 
             env.stop().await;
+
+            assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
         }
 
         #[tokio::test]
@@ -1175,14 +1181,18 @@ mod configured_as_whitelisted {
         use bittorrent_primitives::info_hash::InfoHash;
         use torrust_tracker_primitives::peer::fixture::PeerBuilder;
         use torrust_tracker_test_helpers::configuration;
+        use tracing::level_filters::LevelFilter;
 
+        use crate::common::logging::{self, logs_contains_a_line_with};
         use crate::servers::http::asserts::assert_scrape_response;
         use crate::servers::http::client::Client;
         use crate::servers::http::responses::scrape::{File, ResponseBuilder};
         use crate::servers::http::{requests, Started};
 
         #[tokio::test]
         async fn should_return_the_zeroed_file_when_the_requested_file_is_not_whitelisted() {
+            logging::setup(LevelFilter::ERROR);
+
             let env = Started::new(&configuration::ephemeral_listed().into()).await;
 
             let info_hash = InfoHash::from_str("9c38422213e30bff212b30c360d26f9a02136422").unwrap();
@@ -1208,6 +1218,8 @@ mod configured_as_whitelisted {
             assert_scrape_response(response, &expected_scrape_response).await;
 
             env.stop().await;
+
+            assert!(logs_contains_a_line_with(&["ERROR", "tower_http", "response failed"]));
         }
 
         #[tokio::test]