30、测试与调试Rust微服务

测试与调试Rust微服务

在开发Rust微服务时，测试和调试是确保服务质量和稳定性的关键环节。下面将详细介绍如何对Rust微服务进行测试和调试。

1. 工具函数与集成测试客户端

首先，我们需要定义一些工具函数和一个集成测试客户端。

• 地址拼接函数 ：

pub fn url(url: &str, path: &str) -> String {
    url.to_owned() + path
}

• 随机字符串生成函数 ：

use rand::{thread_rng, Rng};
use rand::distributions::Alphanumeric;
use std::iter;

pub fn rand_str() -> String {
    let mut rng = thread_rng();
    iter::repeat(())
            .map(|()| rng.sample(Alphanumeric))
            .take(7)
            .collect()
}

• 线程休眠函数 ：

use std::thread;
use std::time::Duration;

pub fn wait(s: u64) {
    thread::sleep(Duration::from_secs(s));
}

接下来，我们定义一个集成测试客户端 WebApi ：

use reqwest::{Client, RedirectPolicy};
use reqwest::cookie::CookieJar;
use http::StatusCode;
use std::collections::HashMap;
use serde_json::Deserialize;
use http::Method;

pub struct WebApi {
    client: Client,
    url: String,
    jar: CookieJar,
}

impl WebApi {
    fn new(url: &str) -> Self {
        let client = Client::builder()
            .redirect(RedirectPolicy::none())
            .build()
            .unwrap();
        Self {
            client,
            url: url.into(),
            jar: CookieJar::new(),
        }
    }
}

pub fn users() -> WebApi { WebApi::new(USERS) }
pub fn mailer() -> WebApi { WebApi::new(MAILER) }
pub fn content() -> WebApi { WebApi::new(CONTENT) }
pub fn router() -> WebApi { WebApi::new(ROUTER) }

为 WebApi 添加一些方法：

impl WebApi {
    pub fn healthcheck(&mut self, path: &str, content: &str) {
        let url = url(&self.url, path);
        let mut resp = reqwest::get(&url).unwrap();
        assert_eq!(resp.status(), StatusCode::OK);
        let text = resp.text().unwrap();
        assert_eq!(text, content);
    }

    pub fn request<'a, I, J>(&mut self, method: Method, path: &'a str, values: I) -> J
    where
        I: IntoIterator<Item = (&'a str, &'a str)>,
        J: for <'de> Deserialize<'de>,
    {
        let url = url(&self.url, path);
        let params = values.into_iter().collect::<HashMap<_, _>>();
        let mut resp = self.client.request(method, &url)
            .form(&params)
            .send()
            .unwrap();
        let status = resp.status().to_owned();
        let text = resp
            .text()
            .unwrap();
        if status != StatusCode::OK {
            panic!("Bad response [{}] of '{}': {}", resp.status(), path, text);
        }
        let value = serde_json::from_str(&text);
        match value {
            Ok(value) => value,
            Err(err) => {
                panic!("Can't convert '{}': {}", text, err);
            },
        }
    }

    pub fn check_status<'a, I>(&mut self, method: Method, path: &'a str, values: I, status: StatusCode)
    where
        I: IntoIterator<Item = (&'a str, &'a str)>,
    {
        let url = url(&self.url, path);
        let params = values.into_iter().collect::<HashMap<_, _>>();
        let cookies = self.jar.iter()
            .map(|kv| format!("{}={}", kv.name(), kv.value()))
            .collect::<Vec<_>>()
            .join(";");
        let resp = self.client.request(method, &url)
            .header("Cookie", cookies)
            .form(&params)
            .send()
            .unwrap();
        if let Some(value) = resp.headers().get("Set-Cookie") {
            let raw_cookie = value.to_str().unwrap().to_owned();
            let cookie = reqwest::cookie::Cookie::parse(raw_cookie).unwrap();
            self.jar.add(cookie);
        }
        assert_eq!(status, resp.status());
    }
}

2. 类型定义

在开始编写测试之前，我们需要定义一些与微服务交互所需的类型。创建一个 types.rs 文件：

use serde_derive::Deserialize;
use uuid::Uuid;

#[derive(Deserialize)]
pub struct UserId {
    id: Uuid,
}

#[derive(Deserialize)]
pub struct Comment {
    pub id: i32,
    pub uid: String,
    pub text: String,
}

3. 微服务测试

接下来，我们分别对各个微服务进行测试。

3.1 用户微服务测试

创建一个 users.rs 文件：

mod types;
mod utils;
use self::types::UserId;
use self::utils::{Method, WebApi};

#[test]
fn users_healthcheck() {
    let mut api = WebApi::users();
    api.healthcheck("/", "Users Microservice");
}

#[test]
fn check_signup_and_signin() {
    let mut api = WebApi::users();
    let username = utils::rand_str() + "@example.com";
    let password = utils::rand_str();
    let params = vec![
        ("email", username.as_ref()),
        ("password", password.as_ref()),
    ];
    let _: () = api.request(Method::POST, "/signup", params);
    let params = vec![
        ("email", username.as_ref()),
        ("password", password.as_ref()),
    ];
    let _: UserId = api.request(Method::POST, "/signin", params);
}

3.2 内容微服务测试

创建一个 content.rs 文件：

mod types;
mod utils;
use self::utils::{Method, WebApi};
use self::types::Comment;

#[test]
fn content_healthcheck() {
    let mut api = WebApi::content();
    api.healthcheck("/", "Content Microservice");
}

#[test]
fn add_comment() {
    let mut api = WebApi::content();
    let uuid = uuid::Uuid::new_v4().to_string();
    let comment = utils::rand_str();
    let params = vec![
        ("uid", uuid.as_ref()),
        ("text", comment.as_ref()),
    ];
    let _: () = api.request(Method::POST, "/new_comment", params);
    let comments: Vec<Comment> = api.request(Method::GET, "/list", vec![]);
    assert!(comments.into_iter().any(|Comment { text, ..}| { text == comment }))
}

3.3 邮件微服务测试

创建一个 mailer.rs 文件：

mod utils;
use self::utils::{Method, WebApi};

#[test]
fn mails_healthcheck() {
    let mut api = WebApi::mailer();
    api.healthcheck("/", "Mailer Microservice");
}

#[test]
fn send_mail() {
    let mut api = WebApi::mailer();
    let email = utils::rand_str() + "@example.com";
    let code = utils::rand_str();
    let params = vec![
        ("to", email.as_ref()),
        ("code", code.as_ref()),
    ];
    let sent: bool = api.request(Method::POST, "/send", params);
    assert!(sent);
}

3.4 路由微服务测试

创建一个 router.rs 文件：

mod types;
mod utils;
use self::utils::{Method, StatusCode, WebApi};
use self::types::Comment;

#[test]
fn router_healthcheck() {
    let mut api = WebApi::router();
    api.healthcheck("/healthcheck", "Router Microservice");
}

#[test]
fn check_router_full() {
    let mut api = WebApi::router();
    let username = utils::rand_str() + "@example.com";
    let password = utils::rand_str();
    let params = vec![
        ("email", username.as_ref()),
        ("password", password.as_ref()),
    ];
    api.check_status(Method::POST, "/api/signup", params, StatusCode::FOUND);
    let params = vec![
        ("email", username.as_ref()),
        ("password", password.as_ref()),
    ];
    api.check_status(Method::POST, "/api/signin", params, StatusCode::FOUND);
    let comment = utils::rand_str();
    let params = vec![
        ("text", comment.as_ref()),
    ];
    api.check_status(Method::POST, "/api/new_comment", params, StatusCode::FOUND);
    let comments: Vec<Comment> = api.request(Method::GET, "/api/comments", vec![]);
    assert!(comments.into_iter().any(|Comment { text, ..}| { text == comment }))
}

微服务测试流程

graph LR
    A[开始] --> B[用户微服务测试]
    B --> C[内容微服务测试]
    C --> D[邮件微服务测试]
    D --> E[路由微服务测试]
    E --> F[结束]

测试工具总结

工具名称	类型	用途
curl	命令行工具	发送HTTP请求，可设置方法、头信息、请求体等
Postman	GUI工具	测试REST API，可分组请求和使用变量
mitmproxy	代理工具	跟踪所有通过它的请求
LLDB	命令行调试器	对程序进行逐步调试
VS Code	编辑器	与LLDB集成，方便调试

调试工具使用方法

4.1 curl

curl是一个常用的命令行工具，用于发送HTTP请求。以下是一些常用参数：
- --request <METHOD> （或 -X ）：设置HTTP方法。
- --header "Header: Value" （或 -H ）：设置请求头。
- --data <data> （或 -d ）：设置请求体，使用 @filename 可附加文件内容。
- --form "field=value" （或 -F ）：设置表单字段。
- --cookie <file> （或 -b ）：设置要发送的cookie文件。
- --cookie-jar <file> （或 -c ）：设置要存储的cookie文件。

示例：
- 发送JSON文件请求：

curl -X POST -H "Content-Type: application/json" -d @file.json http://localhost:8080/upload

• 发送表单请求：

curl -X POST -F login=user -F password=secret http://localhost:8080/register

• 保持cookie：

curl -b session.file -c session.file ...

4.2 Postman

Postman是一个流行的浏览器扩展和桌面应用程序，可从 https://www.getpostman.com/ 获取。使用步骤如下：
1. 安装Postman并创建一个新的工作区，例如 Rust Microservices 。
2. 输入应用程序的URL，设置请求方法为 POST 。
3. 添加请求体为 x-www-form-unlencoded ，并设置参数（如 email 和 password ）。
4. 点击 Send 按钮发送请求。

4.3 mitmproxy

mitmproxy是一个用于跟踪请求的代理工具，可从 https://mitmproxy.org/ 获取。使用步骤如下：
1. 安装mitmproxy。
2. 启动代理：

mitmweb --mode reverse:http://localhost:7000 --web-port 7777 --listen-port 7780

3. 在浏览器中打开 127.0.0.1:7777 查看代理界面，打开 127.0.0.1:7780 与应用程序交互。

4.4 LLDB

LLDB是一个现代的命令行调试器，是LLVM项目的一部分。使用步骤如下：
1. 进入微服务目录，使用 cargo build 编译项目（不要设置 --release 标志）。
2. 启动调试器：

rust-lldb ./target/debug/router-microservice

3. 设置断点：

breakpoint set --name comments

4. 启动微服务：

run

5. 在浏览器中访问 http://localhost:8080/comments ，调试器会在断点处中断。
6. 使用以下命令进行调试：
   • thread list ：查看活动线程。
   • frame variable ：查看当前上下文的变量。
   • next ：执行到下一行代码。
   • continue ：继续执行。

通过以上测试和调试工具，我们可以确保Rust微服务的质量和稳定性，及时发现并解决问题。

测试与调试Rust微服务（续）

5. 调试工具的选择与应用场景

不同的调试工具适用于不同的场景，下面为大家详细介绍各个工具的适用场景，以便在实际开发中做出合适的选择。

工具名称	适用场景
curl	当你需要快速验证一个HTTP请求，或者在脚本中自动化执行请求时，curl是一个很好的选择。它可以方便地设置各种请求参数，并且支持多种数据格式。
Postman	对于需要频繁测试REST API，并且希望对请求进行分组管理和使用变量的情况，Postman的图形化界面和丰富的功能可以提高测试效率。
mitmproxy	当你需要跟踪浏览器与应用程序之间的所有请求和响应，了解请求的详细信息，或者模拟特定的网络环境时，mitmproxy可以帮助你实现这些需求。
LLDB	当你遇到代码逻辑错误，需要逐行调试代码，查看变量的值和程序的执行流程时，LLDB这种传统的命令行调试器可以提供强大的调试功能。
VS Code	如果你更喜欢在编辑器中进行调试，并且希望利用VS Code的丰富插件和集成功能，那么VS Code与LLDB的集成可以为你提供一个舒适的调试环境。

6. 调试流程示例

下面以调试路由微服务为例，展示一个完整的调试流程。

graph LR
    A[发现问题] --> B[选择调试工具]
    B --> C{工具类型}
    C -- 命令行工具 --> D[curl或LLDB]
    C -- GUI工具 --> E[Postman或VS Code]
    C -- 代理工具 --> F[mitmproxy]
    D --> G[执行请求或设置断点]
    E --> G
    F --> H[跟踪请求和响应]
    G --> I[分析结果]
    H --> I
    I --> J{是否解决问题}
    J -- 是 --> K[结束调试]
    J -- 否 --> B

7. 调试技巧与注意事项

在使用调试工具时，还需要掌握一些技巧和注意事项，以提高调试效率和准确性。

7.1 调试技巧

• 使用日志 ：在代码中添加适当的日志信息，可以帮助你快速定位问题。例如，在关键函数的入口和出口处记录日志，输出重要变量的值。

fn important_function() {
    log::debug!("Entering important_function");
    // 函数逻辑
    log::debug!("Exiting important_function");
}

• 缩小范围 ：当遇到复杂的问题时，可以逐步缩小问题的范围。例如，先检查整个微服务的健康状态，然后逐步检查各个功能模块。
• 使用条件断点 ：在LLDB中，可以设置条件断点，只有当满足特定条件时，程序才会在断点处中断。例如：

breakpoint set --name comments --condition "id == 10"

7.2 注意事项

• 编译选项 ：在编译项目时，要确保不使用 --release 标志，否则会移除所有调试信息。如果直接使用 rustc 编译，需要添加 -g -C debuginfo=2 参数。
• 环境一致性 ：在调试时，要确保开发环境和生产环境的一致性，包括依赖库的版本、配置文件等。
• 备份数据 ：在进行调试时，可能会对数据进行修改，因此要提前备份重要数据，以免造成数据丢失。

8. 总结

测试和调试是Rust微服务开发中不可或缺的环节。通过合理使用各种测试工具和调试技巧，可以确保微服务的质量和稳定性，及时发现并解决潜在的问题。

• 测试方面 ：我们定义了工具函数和集成测试客户端，对各个微服务进行了单独测试和综合测试，确保每个微服务的功能正常。
• 调试方面 ：介绍了多种调试工具，包括curl、Postman、mitmproxy、LLDB和VS Code，并详细说明了它们的使用方法和适用场景。同时，还分享了一些调试技巧和注意事项，帮助你提高调试效率。

希望这些内容对你在Rust微服务的开发和调试过程中有所帮助。在实际应用中，要根据具体情况选择合适的工具和方法，不断积累经验，提高自己的开发和调试能力。