Rust fakeクレート完全ガイド｜テストデータ自動生成の実践テクニック

[dev-dependencies]
fake = { version = "4.4", features = ["derive"] }

[dev-dependencies]
fake = { version = "4.4", features = ["derive", "uuid", "chrono", "rust-decimal"] }
uuid = { version = "1", features = ["v4"] }
chrono = "0.4"

use fake::faker::name::en::*;
use fake::faker::address::en::*;
use fake::faker::phone_number::en::*;
use fake::Fake;

fn main() {
    let full_name: String = Name().fake();
    let city: String = CityName().fake();
    let phone: String = PhoneNumber().fake();

    println!("Name: {full_name}");   // 例: "Telly Gorczany"
    println!("City: {city}");        // 例: "North Allentown"
    println!("Phone: {phone}");      // 例: "1-234-567-8901"
}

use fake::faker::number::en::*;
use fake::faker::boolean::en::*;
use fake::faker::lorem::en::*;
use fake::Fake;

fn main() {
    let digit: String = Digit().fake();
    let flag: bool = Boolean(50).fake(); // 50%の確率でtrue
    let sentence: String = Sentence(5..10).fake();

    println!("{digit}, {flag}, {sentence}");
}

use fake::faker::internet::en::*;
use fake::Fake;

fn main() {
    let email: String = FreeEmail().fake();
    let username: String = Username().fake();
    let ipv4: String = IPv4().fake();

    println!("{email}, {username}, {ipv4}");
}

use fake::faker::name::raw::*;
use fake::locales::JA_JP;
use fake::Fake;

fn main() {
    let name: String = Name(JA_JP).fake();
    let first: String = FirstName(JA_JP).fake();
    let last: String = LastName(JA_JP).fake();

    println!("{name}");  // 例: "山下 湊翔"
    println!("{last} {first}");
}

use fake::{Dummy, Fake, Faker};

#[derive(Debug, Dummy)]
struct User {
    #[dummy(faker = "1000..9999")]
    id: u64,
    #[dummy(faker = "fake::faker::name::en::Name()")]
    name: String,
    #[dummy(faker = "fake::faker::internet::en::FreeEmail()")]
    email: String,
}

#[test]
fn test_user_creation() {
    let user: User = Faker.fake();
    assert!(user.id >= 1000 && user.id < 9999);
    assert!(!user.name.is_empty());
    assert!(user.email.contains('@'));
}

use fake::{Dummy, Fake, Faker};

#[derive(Debug, Dummy)]
enum Status {
    Active,
    Inactive,
    Suspended,
}

#[derive(Debug, Dummy)]
struct Account {
    #[dummy(faker = "1..1000")]
    id: u32,
    status: Status,
}

#[test]
fn test_account_status_variation() {
    let accounts: Vec<Account> = (0..100).map(|_| Faker.fake()).collect();
    // 100件生成すれば各Statusが少なくとも1件は含まれる可能性が高い
    let has_active = accounts.iter().any(|a| matches!(a.status, Status::Active));
    let has_inactive = accounts.iter().any(|a| matches!(a.status, Status::Inactive));
    assert!(has_active || has_inactive);
}

use fake::{Dummy, Fake, Faker};
use rand::Rng;

struct DateRange {
    start: u32,
    end: u32,
}

impl Dummy<Faker> for DateRange {
    fn dummy_with_rng<R: Rng + ?Sized>(_config: &Faker, rng: &mut R) -> Self {
        let start = rng.gen_range(1..100);
        let end = rng.gen_range(start..start + 50);
        DateRange { start, end }
    }
}

use fake::faker::chrono::en::*;
use fake::Fake;
use chrono::{NaiveDate, NaiveDateTime};

#[test]
fn test_fake_dates() {
    let date: NaiveDate = Date().fake();
    let datetime: NaiveDateTime = DateTime().fake();
    // chrono型がそのまま返るため、追加のパースが不要
    assert!(date.year() > 0);
    println!("{date}, {datetime}");
}

use fake::uuid::UUIDv4;
use fake::Fake;
use uuid::Uuid;

#[test]
fn test_fake_uuid() {
    let id: Uuid = UUIDv4.fake();
    assert_eq!(id.get_version(), Some(uuid::Version::Random));
}

use fake::{Fake, Faker};
use rand::SeedableRng;
use rand::rngs::StdRng;

#[test]
fn test_deterministic_fake() {
    let mut rng = StdRng::seed_from_u64(42);
    let name1: String = Faker.fake_with_rng(&mut rng);

    let mut rng2 = StdRng::seed_from_u64(42);
    let name2: String = Faker.fake_with_rng(&mut rng2);

    assert_eq!(name1, name2); // 同一シードなら同じ値
}

use fake::{Fake, Faker};
use fake::faker::name::en::Name;

#[test]
fn test_bulk_generation() {
    // イテレータで10件生成
    let names: Vec<String> = (0..10)
        .map(|_| Name().fake())
        .collect();
    assert_eq!(names.len(), 10);

    // Rangeを使った数値の一括生成
    let scores: Vec<u32> = (0..5)
        .map(|_| (0u32..100).fake())
        .collect();
    assert!(scores.iter().all(|s| *s < 100));
}

use fake::{Dummy, Fake, Faker};

#[derive(Debug, Clone, Dummy)]
struct CreateUserInput {
    #[dummy(faker = "fake::faker::name::en::Name()")]
    name: String,
    #[dummy(faker = "fake::faker::internet::en::FreeEmail()")]
    email: String,
    #[dummy(faker = "18..65u32")]
    age: u32,
}

#[test]
fn test_create_user() {
    let input: CreateUserInput = Faker.fake();
    // repositoryにinputを渡してテスト
    assert!(!input.name.is_empty());
    assert!(input.email.contains('@'));
    assert!(input.age >= 18 && input.age < 65);
}

use fake::{Dummy, Fake, Faker};

#[derive(Debug, Dummy, serde::Serialize)]
struct ApiResponse {
    #[dummy(faker = "200..299u16")]
    status: u16,
    #[dummy(faker = "fake::faker::lorem::en::Sentence(3..8)")]
    message: String,
}

#[test]
fn test_api_response_handling() {
    let resp: ApiResponse = Faker.fake();
    let json = serde_json::to_string(&resp).unwrap();
    assert!(json.contains("status"));
}

use fake::{Fake, Faker};
use fake::faker::name::en::Name;
use fake::faker::internet::en::FreeEmail;

/// テスト用のユーザー情報を生成するヘルパー
fn fake_user() -> (String, String) {
    let name: String = Name().fake();
    let email: String = FreeEmail().fake();
    (name, email)
}

#[test]
fn test_with_helper() {
    let (name, email) = fake_user();
    assert!(!name.is_empty());
    assert!(email.contains('@'));
}

fake = { version = "4.4", features = ["derive"] }

fake = { version = "4.4", features = ["derive", "chrono"] }

// OK: enモジュール（ロケール引数なし）
use fake::faker::name::en::Name;
let name: String = Name().fake();

// OK: rawモジュール（ロケール引数あり）
use fake::faker::name::raw::Name;
use fake::locales::JA_JP;
let name: String = Name(JA_JP).fake();