Rust资产测试工具库asset-test-utils的使用，高效管理测试资源与模拟资产环境

安装

在项目目录中运行以下Cargo命令：

cargo add asset-test-utils

或者在Cargo.toml中添加以下行：

asset-test-utils = "25.0.0"

基本使用示例

use asset_test_utils::{Asset, AssetRegistry, MockEnvironment};

// 创建模拟资产环境
let mut mock_env = MockEnvironment::new();

// 创建资产注册表
let mut registry = AssetRegistry::new();

// 注册测试资产
let asset1 = Asset::new("asset1", "path/to/asset1");
let asset2 = Asset::new("asset2", "path/to/asset2");

registry.register(asset1);
registry.register(asset2);

// 将注册表添加到模拟环境
mock_env.add_registry(registry);

// 在测试中使用模拟环境
let loaded_asset = mock_env.load_asset("asset1").unwrap();
assert_eq!(loaded_asset.id(), "asset1");

完整示例

use asset_test_utils::{Asset, AssetRegistry, MockEnvironment, AssetLoader};
use std::path::PathBuf;

#[test]
fn test_asset_loading() {
    // 1. 设置模拟环境
    let mut mock_env = MockEnvironment::new();
    
    // 2. 创建测试资产
    let assets = vec![
        Asset::new("texture", "assets/textures/test.png"),
        Asset::new("model", "assets/models/test.obj"),
        Asset::new("shader", "assets/shaders/test.glsl"),
    ];
    
    // 3. 创建并配置资产注册表
    let mut registry = AssetRegistry::new();
    for asset in assets {
        registry.register(asset);
    }
    
    // 4. 将注册表添加到环境
    mock_env.add_registry(registry);
    
    // 5. 创建资产加载器
    let loader = AssetLoader::new(mock_env);
    
    // 6. 测试资产加载
    let texture = loader.load("texture").unwrap();
    assert_eq!(texture.path(), PathBuf::from("assets/textures/test.png"));
    
    let model = loader.load("model").unwrap();
    assert_eq!(model.path(), PathBuf::from("assets/models/test.obj"));
    
    // 7. 测试不存在的资产
    assert!(loader.load("non_existent").is_err());
}

高级功能

use asset_test_utils::{Asset, AssetRegistry, MockEnvironment, LoadBehavior, ErrorScenario};

#[test]
fn test_advanced_features() {
    let mut env = MockEnvironment::new();
    let mut registry = AssetRegistry::new();
    
    // 配置资产加载行为
    let mut asset = Asset::new("slow_asset", "path/to/slow");
    asset.set_load_behavior(LoadBehavior::Delayed);
    
    // 配置错误场景
    let mut error_asset = Asset::new("error_asset", "path/to/error");
    error_asset.set_error_scenario(ErrorScenario::LoadFailure);
    
    registry.register(asset);
    registry.register(error_asset);
    env.add_registry(registry);
    
    // 测试延迟加载
    let loader = AssetLoader::new(env);
    let slow = loader.load("slow_asset").unwrap();
    assert!(!slow.is_loaded());
    
    // 测试错误场景
    assert!(loader.load("error_asset").is_err());
}

完整示例demo

下面是一个更完整的demo示例，展示了asset-test-utils在实际项目中的典型用法：

use asset_test_utils::{
    Asset, 
    AssetRegistry, 
    MockEnvironment, 
    AssetLoader,
    LoadBehavior,
    ErrorScenario
};
use std::path::PathBuf;

// 自定义资产类型
#[derive(Debug)]
struct GameTexture {
    id: String,
    path: PathBuf,
    width: u32,
    height: u32
}

impl GameTexture {
    fn new(id: &str, path: &str, width: u32, height: u32) -> Self {
        Self {
            id: id.to_string(),
            path: PathBuf::from(path),
            width,
            height
        }
    }
}

#[test]
fn test_game_asset_system() {
    // 1. 初始化模拟环境
    let mut env = MockEnvironment::new();
    
    // 2. 准备测试资产
    let textures = vec![
        ("player", "assets/player.png", 64, 64),
        ("enemy", "assets/enemy.png", 32, 32),
        ("background", "assets/bg.png", 1024, 768)
    ];
    
    // 3. 创建并配置资产注册表
    let mut registry = AssetRegistry::new();
    
    for (id, path, width, height) in textures {
        // 创建自定义资产对象
        let texture = GameTexture::new(id, path, width, height);
        
        // 转换为通用Asset对象
        let mut asset = Asset::new(id, path);
        asset.set_custom_data(texture); // 存储自定义数据
        
        // 设置不同的加载行为
        match id {
            "player" => asset.set_load_behavior(LoadBehavior::Immediate),
            "enemy" => asset.set_load_behavior(LoadBehavior::Delayed),
            "background" => {
                asset.set_load_behavior(LoadBehavior::Immediate);
                asset.set_error_scenario(ErrorScenario::LoadFailure);
            },
            _ => {}
        }
        
        registry.register(asset);
    }
    
    // 4. 将注册表添加到环境
    env.add_registry(registry);
    
    // 5. 测试不同场景
    let loader = AssetLoader::new(env);
    
    // 测试立即加载的资产
    let player = loader.load("player").unwrap();
    let player_data: &GameTexture = player.custom_data().unwrap();
    assert_eq!(player_data.width, 64);
    
    // 测试延迟加载的资产
    let enemy = loader.load("enemy").unwrap();
    assert!(!enemy.is_loaded());
    
    // 测试配置了错误的资产
    assert!(loader.load("background").is_err());
    
    // 测试资产依赖
    let mut dependency_asset = Asset::new("dependent", "path/to/dependent");
    dependency_asset.add_dependency("player");
    assert!(dependency_asset.dependencies().contains(&"player".to_string()));
}

这个demo展示了：

1. 如何创建自定义资产类型
2. 如何配置不同的加载行为
3. 如何模拟错误场景
4. 如何测试资产依赖关系
5. 完整的工作流程演示

asset-test-utils可以有效简化资产相关代码的测试工作，特别是在游戏开发、图形应用等需要处理大量资源的场景中。