构建一个rust生产应用读书笔记7-确认邮件2

共享测试辅助

当每个集成测试文件都是一个独立的可执行文件时，共享测试辅助函数的一种常见方法是创建一个单独的模块，该模块可以被全部测试文件导入和使用。这个模块通常包罗全部测试需要共用的辅助函数、常量、配置和其他资源。如果遵循这种做法，你可以按照以下步骤操纵：
在你的 tests 目次下，创建一个名为 helpers 的模块

1. //! tests/health_check.rs
2. // [...]
3. mod helpers;
4. // [...]

复制代码

在 Rust 项目中，如果你将 helpers 模块作为子模块捆绑到像 health_check 如许的测试可执行文件中，那么你可以在你的测试用例中访问它袒露的函数。这种方法一开始工作得很好，但它会导致“函数从未被使用”的告诫，由于 helpers 是作为一个子模块捆绑的，而不是作为第三方 crate 调用的。Cargo 会独立编译每个测试可执行文件，并且如果对于特定的测试文件，helpers 中的一个或多个公共函数从未被调用，就会发出告诫。随着你的测试套件的逐渐增长，这种情况险些是不可避免的——并不是全部的测试文件都会使用全部的辅助方法。
为了避免这些未使用的函数告诫，你可以采用第二种方法，充分利用每个 tests 目次下的文件都是一个独立的可执行文件这一特性：为每个测试创建作用域限定的子模块。详细来说，你可以为不同的测试创建特定的辅助模块，如许只有当测试确实需要时才会包罗这些辅助函数，从而避免了全局辅助模块带来的未使用函数告诫题目。
让我们创建一个 api 文件夹放在 tests 下，并在里面放置一个 main.rs 文件：

• 创建 tests/api 目次。
  
• 在 tests/api 目次下创建 main.rs 文件。这个文件将作为 api 测试的入口点。
  
• 如果有与 api 测试相关的辅助函数，你可以在 tests/api 下创建一个 helpers.rs 或者 mod.rs 文件来存放这些辅助函数。
  
• 确保你在 main.rs 中正确引用了这些辅助函数，例如通过 mod helpers; 来声明 helpers 模块（假设你创建的是 mod.rs）或者直接通过 use api::helpers; 引用它们（如果你创建的是 helpers.rs 并且已经在 main.rs 中声明白 mod helpers;）。
  
• 对于其他不同类型的测试（如 db_tests, service_tests 等），你可以重复上述步骤，为每种类型的测试创建各自的目次和辅助模块。
  

修改后的目次布局如下：

1. tests
2. └── api
3.     ├── health_check.rs
4.     ├── helpers.rs
5.     ├── main.rs
6.     └── subscriptions.rs

复制代码

在main.rs添加子模块

1. mod health_check;
2. mod helpers;
3. mod subscriptions;

复制代码

health_check.rs 到helpers.rs

1. // Ensure that the `tracing` stack is only initialised once using `once_cell`
2. use secrecy::Secret;
3. use sqlx::{Connection, Executor, PgConnection, PgPool};
4. use std::net::TcpListener;
5. use std::sync::LazyLock;
6. use uuid::Uuid;
7. use zero2prod::configuration::{get_configuration, DatabaseSettings};
8. use zero2prod::email_client::EmailClient;
9. use zero2prod::startup::run;
10. use zero2prod::telemetry::{get_subscriber, init_subscriber};
12. static TRACING: LazyLock<()> = LazyLock::new(|| {
13.     let default_filter_level = "info".to_string();
14.     let subscriber_name = "test".to_string();
15.     if std::env::var("TEST_LOG").is_ok() {
16.         let subscriber = get_subscriber(subscriber_name, default_filter_level, std::io::stdout);
17.         init_subscriber(subscriber);
18.     } else {
19.         let subscriber = get_subscriber(subscriber_name, default_filter_level, std::io::sink);
20.         init_subscriber(subscriber);
21.     };
22. });
24. pub struct TestApp {
25.     pub address: String,
26.     pub db_pool: PgPool,
27. }
29. pub async fn spawn_app() -> TestApp {
30.     // The first time `initialize` is invoked the code in `TRACING` is executed.
31.     // All other invocations will instead skip execution.
32.     LazyLock::force(&TRACING);
34.     let listener = TcpListener::bind("127.0.0.1:0").expect("Failed to bind random port");
35.     // We retrieve the port assigned to us by the OS
36.     let port = listener.local_addr().unwrap().port();
37.     let address = format!("http://127.0.0.1:{}", port);
39.     let mut configuration = get_configuration().expect("Failed to read configuration.");
40.     configuration.database.database_name = Uuid::new_v4().to_string();
41.     let connection_pool = configure_database(&configuration.database).await;
43.     let sender_email = configuration
44.         .email_client
45.         .sender()
46.         .expect("Invalid sender email address.");
47.     let timeout = configuration.email_client.timeout();
48.     let email_client = EmailClient::new(
49.         configuration.email_client.base_url,
50.         sender_email,
51.         configuration.email_client.authorization_token,
52.         timeout,
53.     );
55.     let server =
56.         run(listener, connection_pool.clone(), email_client).expect("Failed to bind address");
57.     let _ = tokio::spawn(server);
58.     TestApp {
59.         address,
60.         db_pool: connection_pool,
61.     }
62. }
64. pub async fn configure_database(config: &DatabaseSettings) -> PgPool {
65.     // Create database
66.     let maintenance_settings = DatabaseSettings {
67.         database_name: "postgres".to_string(),
68.         username: "postgres".to_string(),
69.         password: Secret::new("password".to_string()),
70.         ..config.clone()
71.     };
72.     let mut connection = PgConnection::connect_with(&maintenance_settings.connect_options())
73.         .await
74.         .expect("Failed to connect to Postgres");
75.     connection
76.         .execute(format!(r#"CREATE DATABASE "{}";"#, config.database_name).as_str())
77.         .await
78.         .expect("Failed to create database.");
80.     // Migrate database
81.     let connection_pool = PgPool::connect_with(config.connect_options())
82.         .await
83.         .expect("Failed to connect to Postgres.");
84.     sqlx::migrate!("./migrations")
85.         .run(&connection_pool)
86.         .await
87.         .expect("Failed to migrate the database");
88.     connection_pool
89. }

复制代码

注意：spawn_app() 函数需要改成pub，可以让其他类访问
subscriptions.rs

1. use crate::helpers::spawn_app;
3. #[tokio::test]
4. async fn subscribe_returns_a_200_for_valid_form_data() {
5.     // Arrange
6.     let app = spawn_app().await;
7.     let client = reqwest::Client::new();
8.     let body = "name=le%20guin&email=ursula_le_guin%40gmail.com";
10.     // Act
11.     let response = client
12.         .post(&format!("{}/subscriptions", &app.address))
13.         .header("Content-Type", "application/x-www-form-urlencoded")
14.         .body(body)
15.         .send()
16.         .await
17.         .expect("Failed to execute request.");
19.     // Assert
20.     assert_eq!(200, response.status().as_u16());
22.     let saved = sqlx::query!("SELECT email, name FROM subscriptions",)
23.         .fetch_one(&app.db_pool)
24.         .await
25.         .expect("Failed to fetch saved subscription.");
27.     assert_eq!(saved.email, "ursula_le_guin@gmail.com");
28.     assert_eq!(saved.name, "le guin");
29. }
31. #[tokio::test]
32. async fn subscribe_returns_a_400_when_data_is_missing() {
33.     // Arrange
34.     let app = spawn_app().await;
35.     let client = reqwest::Client::new();
36.     let test_cases = vec![
37.         ("name=le%20guin", "missing the email"),
38.         ("email=ursula_le_guin%40gmail.com", "missing the name"),
39.         ("", "missing both name and email"),
40.     ];
42.     for (invalid_body, error_message) in test_cases {
43.         // Act
44.         let response = client
45.             .post(&format!("{}/subscriptions", &app.address))
46.             .header("Content-Type", "application/x-www-form-urlencoded")
47.             .body(invalid_body)
48.             .send()
49.             .await
50.             .expect("Failed to execute request.");
52.         // Assert
53.         assert_eq!(
54.             400,
55.             response.status().as_u16(),
56.             // Additional customised error message on test failure
57.             "The API did not fail with 400 Bad Request when the payload was {}.",
58.             error_message
59.         );
60.     }
61. }
63. #[tokio::test]
64. async fn subscribe_returns_a_400_when_fields_are_present_but_invalid() {
65.     // Arrange
66.     let app = spawn_app().await;
67.     let client = reqwest::Client::new();
68.     let test_cases = vec![
69.         ("name=&email=ursula_le_guin%40gmail.com", "empty name"),
70.         ("name=Ursula&email=", "empty email"),
71.         ("name=Ursula&email=definitely-not-an-email", "invalid email"),
72.     ];
74.     for (body, description) in test_cases {
75.         // Act
76.         let response = client
77.             .post(&format!("{}/subscriptions", &app.address))
78.             .header("Content-Type", "application/x-www-form-urlencoded")
79.             .body(body)
80.             .send()
81.             .await
82.             .expect("Failed to execute request.");
84.         // Assert
85.         assert_eq!(
86.             400,
87.             response.status().as_u16(),
88.             "The API did not return a 400 Bad Request when the payload was {}.",
89.             description
90.         );
91.     }
92. }

复制代码

恭喜，你已经将测试套件分解为更小、更易管理的模块！这种新的布局带来了几个积极的副作用：

• 递归性：如果 tests/api/subscriptions.rs 文件变得难以管理，你可以将其转换为一个模块。如许，tests/api/subscriptions/helpers.rs 可以生存订阅特定的测试辅助函数，并且可以有多个专注于特定流程或题目标测试文件。这使得纵然当某个部分变得复杂时，你仍旧能够保持精良的构造布局。
  
• 封装：你的测试只需要知道关于 spawn_app 和 TestApp 的信息——没有须要袒露 configure_database 或 TRACING 如许的细节。通过将这些复杂性潜伏在 helpers 模块中，你可以使测试代码更加简便和易于理解。
  
• 单个测试二进制文件：如果你有一个大型测试套件并且使用的是扁平文件布局，那么每次运行 cargo test 时，你大概会构建数十个可执行文件。固然每个可执行文件是并行编译的，但链接阶段却是完全顺序进行的！将全部测试用例捆绑到一个可执行文件中可以减少在连续集成（CI）情况中编译测试套件所花费的时间。
  

修改启动业务

从代码布局的角度来看，启动逻辑可以被筹划为一个函数，该函数接收 Settings 作为输入，并返回应用步伐实例作为输出。因此， main 函数应该尽量简便，主要负责调用这个启动逻辑函数并处理任何高层级的错误。

1. //!main.rs
2. use zero2prod::{
3.     configuration::get_configuration,
4.     telemetry::{get_subscriber, init_subscriber},
5. };
7. #[tokio::main]
8. async fn main() -> std::io::Result<()> {
9.     let subscriber = get_subscriber("zero2prod".into(), "info".into(), std::io::stdout);
10.     init_subscriber(subscriber);
12.     let configuration = get_configuration().expect("Failed to read configuration.");
13.     let application = Application::build(configuration).await?;
14.     application.run_util_stoped().await?;
15.     Ok(())
16. }

复制代码

startup.rs重构 

1. //startup.rs
2. use crate::configuration::{DatabaseSettings, Settings};
3. use crate::email_client::EmailClient;
4. use crate::routes::{health_check, subscribe};
5. use actix_web::dev::Server;
6. use actix_web::web::Data;
7. use actix_web::{web, App, HttpServer};
8. use sqlx::postgres::PgPoolOptions;
9. use sqlx::PgPool;
10. use std::net::TcpListener;
11. use tracing_actix_web::TracingLogger;
13. pub struct Application {
14.     port: u16,
15.     server: Server,
16. }
18. impl Application {
19.     pub async fn build(configuration: Settings) -> Result<Self, std::io::Error> {
20.         let connection_pool = get_connection_pool(&configuration.database);
21.         let sender_email = configuration
22.             .email_client
23.             .sender()
24.             .expect("Invalid sender email address.");
25.         let timeout = configuration.email_client.timeout();
26.         let email_client = EmailClient::new(
27.             configuration.email_client.base_url,
28.             sender_email,
29.             configuration.email_client.authorization_token,
30.             timeout,
31.         );
32.         let address = format!(
33.             "{}:{}",
34.             configuration.application.host, configuration.application.port
35.         );
36.         let listener = TcpListener::bind(address)?;
37.         let port = listener.local_addr().unwrap().port();
38.         let server = run(listener, connection_pool, email_client)?;
39.         Ok(Self { port, server })
40.     }
42.     pub fn port(&self) -> u16 {
43.         self.port
44.     }
46.     pub async fn run_util_stoped(self) -> Result<(), std::io::Error> {
47.         self.server.await
48.     }
49. }
51. pub fn get_connection_pool(configuration: &DatabaseSettings) -> PgPool {
52.     PgPoolOptions::new().connect_lazy_with(configuration.connect_options())
53. }
55. pub fn run(
56.     listener: TcpListener,
57.     db_pool: PgPool,
58.     email_client: EmailClient,
59. ) -> Result<Server, std::io::Error> {
60.     let db_pool = Data::new(db_pool);
61.     let email_client = Data::new(email_client);
62.     let server = HttpServer::new(move || {
63.         App::new()
64.             .wrap(TracingLogger::default())
65.             .route("/health_check", web::get().to(health_check))
66.             .route("/subscriptions", web::post().to(subscribe))
67.             .app_data(db_pool.clone())
68.             .app_data(email_client.clone())
69.     })
70.     .listen(listener)?
71.     .run();
72.     Ok(server)
73. }

复制代码

helpers重构

1. pub async fn spawn_app() -> TestApp {
2.     LazyLock::force(&TRACING);
4.     let configuration = {
5.         let mut c = get_configuration().expect("Failed to read configuration.");
6.         c.database.database_name = Uuid::new_v4().to_string();
7.         c.application.port = 0;
8.         c
9.     };
11.     configure_database(&configuration.database).await;
13.     let application = Application::build(configuration.clone())
14.         .await
15.         .expect("Failed to build application.");
16.     let address = format!("http://localhost:{}", application.port());
17.     let _ = tokio::spawn(application.run_util_stoped());
19.     TestApp {
20.         address,
21.         db_pool: get_connection_pool(&configuration.database),
22.     }
23. }

复制代码

构建API Client

helpers.rs

1. //[..]
2. impl TestApp {
3.     pub async fn post_subscriptions(&self, body: String) -> reqwest::Response {
4.         reqwest::Client::new()
5.             .post(&format!("{}/subscriptions", &self.address))
6.             .header("Content-Type", "application/x-www-form-urlencoded")
7.             .body(body)
8.             .send()
9.             .await
10.             .expect("Failed to execute reuest.")
11.     }
12. }
14. //[..]

复制代码

subscriptions.rs

1. use crate::helpers::spawn_app;
3. #[tokio::test]
4. async fn subscribe_returns_a_200_for_valid_form_data() {
5.     // Arrange
6.     let app = spawn_app().await;
7.     let body = "name=le%20guin&email=ursula_le_guin%40gmail.com";
9.     // Act
10.     let response = app.post_subscriptions(body.into()).await;
12.     // Assert
13.     assert_eq!(200, response.status().as_u16());
15.     let saved = sqlx::query!("SELECT email, name FROM subscriptions",)
16.         .fetch_one(&app.db_pool)
17.         .await
18.         .expect("Failed to fetch saved subscription.");
20.     assert_eq!(saved.email, "ursula_le_guin@gmail.com");
21.     assert_eq!(saved.name, "le guin");
22. }
24. #[tokio::test]
25. async fn subscribe_returns_a_400_when_data_is_missing() {
26.     // Arrange
27.     let app = spawn_app().await;
28.     let client = reqwest::Client::new();
29.     let test_cases = vec![
30.         ("name=le%20guin", "missing the email"),
31.         ("email=ursula_le_guin%40gmail.com", "missing the name"),
32.         ("", "missing both name and email"),
33.     ];
35.     for (invalid_body, error_message) in test_cases {
36.         // Act
37.         let response = app.post_subscriptions(invalid_body.into()).await;
39.         // Assert
40.         assert_eq!(
41.             400,
42.             response.status().as_u16(),
43.             // Additional customised error message on test failure
44.             "The API did not fail with 400 Bad Request when the payload was {}.",
45.             error_message
46.         );
47.     }
48. }
50. #[tokio::test]
51. async fn subscribe_returns_a_400_when_fields_are_present_but_invalid() {
52.     // Arrange
53.     let app = spawn_app().await;
54.     let test_cases = vec![
55.         ("name=&email=ursula_le_guin%40gmail.com", "empty name"),
56.         ("name=Ursula&email=", "empty email"),
57.         ("name=Ursula&email=definitely-not-an-email", "invalid email"),
58.     ];
60.     for (body, description) in test_cases {
61.         // Act
62.         let response = app.post_subscriptions(body.into()).await;
63.         // Assert
64.         assert_eq!(
65.             400,
66.             response.status().as_u16(),
67.             "The API did not return a 400 Bad Request when the payload was {}.",
68.             description
69.         );
70.     }
71. }

复制代码

目前为止，我们完成了第二阶段的重构，代码布局看起来视乎更清楚，接下来继续.....

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。