Mohammad Waseem

Posted on Feb 1

Automating Test Account Management with Rust and Open Source Tools

#rust #devops #automation

Managing test accounts efficiently is a common challenge in DevOps workflows, especially when testing environments require frequent creation, updates, and cleanup of user data. Traditionally, this task can become cumbersome and error-prone if handled manually or through ad hoc scripts. In this post, we’ll explore how to leverage Rust, a systems programming language, along with open source tools, to develop a robust solution for managing test accounts in a scalable and secure manner.

Why Rust for Test Account Management?

Rust offers safety guarantees, high performance, and a growing ecosystem of libraries suitable for automation and API interaction. Its emphasis on reliability ensures that test account management scripts are less prone to faults, leading to more stable CI/CD pipelines.

Approach Overview

Our solution involves creating a command-line tool in Rust that interacts with the user management API of your service (e.g., a REST API). The key features include:

Batch creation of test accounts with configurable parameters.
Automated cleanup of outdated or unused accounts.
Secure handling of API tokens and credentials.

To achieve this, we will use open source Rust crates such as reqwest for HTTP requests, clap for command-line argument parsing, and dotenv for environment variable management.

Implementation Details

Step 1: Setting Up Dependencies

[dependencies]
reqwest = { version = "0.11", features = ["json"] }
clap = { version = "4.0" }
dotenv = "0.15"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

Step 2: Structuring the CLI

use clap::Parser;

#[derive(Parser)]
pub struct Args {
    #[clap(short, long)]
    create: bool,
    #[clap(short, long)]
    cleanup: bool,
    #[clap(short, long, default_value = "10")]
    count: usize,
}

fn main() {
    let args = Args::parse();
    dotenv::dotenv().ok();
    // Load API token from environment variables
    let api_token = std::env::var("API_TOKEN").expect("API_TOKEN must be set");
    if args.create {
        create_test_accounts(args.count, &api_token);
    } else if args.cleanup {
        cleanup_test_accounts(&api_token);
    }
}

Step 3: Creating Test Accounts

use reqwest::Client;
use serde::Serialize;

#[derive(Serialize)]
struct NewUser {
    username: String,
    email: String,
}

async fn create_test_accounts(count: usize, token: &str) {
    let client = Client::new();
    for i in 0..count {
        let username = format!("testuser_{}", i);
        let email = format!("{}@example.com", username);
        let user = NewUser { username, email };
        let response = client.post("https://api.yourservice.com/users")
            .bearer_auth(token)
            .json(&user)
            .send()
            .await
            .expect("Failed to send request");
        match response.status() {
            reqwest::StatusCode::CREATED => println!("Created user {}", user.username),
            _ => println!("Failed to create {}", user.username),
        }
    }
}

Step 4: Automating Cleanup

async fn cleanup_test_accounts(token: &str) {
    let client = Client::new();
    let response = client.get("https://api.yourservice.com/users?filter=test")
        .bearer_auth(token)
        .send()
        .await
        .expect("Failed to fetch users");
    if response.status().is_success() {
        let users: Vec<serde_json::Value> = response.json().await.expect("Invalid JSON");
        for user in users {
            if let Some(user_id) = user.get("id") { 
                let delete_response = client.delete(&format!("https://api.yourservice.com/users/{}", user_id))
                    .bearer_auth(token)
                    .send()
                    .await
                    .expect("Failed to delete user");
                if delete_response.status().is_success() {
                    println!("Deleted user {}", user_id);
                } else {
                    println!("Failed to delete user {}", user_id);
                }
            }
        }
    }
}

Best Practices and Security

Store API tokens securely using environment variables and avoid hardcoding credentials.
Use async/await for concurrent requests when managing large numbers of accounts.
Incorporate logging and error handling for production-grade resilience.

Conclusion

Using Rust in conjunction with open source libraries, DevOps teams can streamline the management of test accounts, ensuring consistency, security, and scalability in testing workflows. This approach minimizes manual overhead, reduces human error, and empowers continuous integration pipelines with reliable automation.

References

Reqwest Crate: https://docs.rs/reqwest
Clap Crate: https://docs.rs/clap
Rust Async Programming: https://rust-lang.github.io/async-book/

Embracing Rust’s safety and performance benefits significantly enhances the robustness of your DevOps automation strategies, especially in critical areas like test data management.

🛠️ QA Tip

Pro Tip: Use TempoMail USA for generating disposable test accounts.

DEV Community