signer-remote 0.4.1

// 测试模块：SignerTransferClient 和 transfer_logic 单元测试
//
// 这些测试不依赖于外部的 signer-hub 服务器，它们专注于测试
// SignerTransferClient 的内部逻辑和 transfer_logic 的功能函数。

use signer_core::{SignerCrypted, SignerServer, SignerUser};
use signer_remote::{
    create_memory_meta,
    // prepare_transfer_data, // 在这个测试文件中未使用
    // receive_and_apply_transfer_data, // 在这个测试文件中未使用
    // SignerSummary, // 在这个测试文件中未使用
    generate_new_account,
    transfer::signer_transfer_message::{
        ChannelDevice, ClientToTransferMessage, TransferToClientMessage,
    },
};
use tokio; // 移除了未使用的 SignerKeys
// use signer_crdt::SignerMeta; // 在这个测试文件中未使用
use std::sync::Arc;
use tokio::sync::Mutex;

/// 单元测试：generate_new_account
///
/// 验证账户生成功能是否正确创建了密钥和用户对象。
#[tokio::test]
async fn test_generate_new_account() {
    let (keys, user) = generate_new_account().expect("生成账户失败");

    // 验证密钥不为空
    assert!(!keys.pub_key.is_empty());
    assert!(!keys.prv_key.is_empty());

    // 验证用户信息
    assert_eq!(user.pub_key, keys.pub_key);
    assert_eq!(user.username, "New User");
    assert!(user.avatar.is_none());
    assert!(user.servers.is_empty());
    // update_time 应该是一个合理的 Unix 时间戳
    assert!(user.update_time > 0);
}

/// 单元测试：create_memory_meta
///
/// 验证基于内存的 SignerMeta 创建功能。
#[tokio::test]
async fn test_create_memory_meta() {
    let (keys, _user) = generate_new_account().expect("生成账户失败");
    let _meta = create_memory_meta(keys).await.expect("创建内存 Meta 失败");

    // 验证 meta 的 keys 与输入一致
    // assert_eq!(meta.keys.pub_key, keys.pub_key); // SignerMeta 的字段是私有的，无法直接访问
    // 这个测试主要是确保函数没有 panic 即可。
    // 一个更完整的测试可能需要 SignerMeta 提供一个公共方法来获取公钥进行比较。
}

/// 单元测试：SignerTransferClient 消息处理回调
///
/// 验证 SignerTransferClient 的回调机制是否能正确地将消息传递给注册的处理函数。
/// 这是一个模拟测试，不涉及实际的网络连接。
#[tokio::test]
async fn test_signer_transfer_client_callbacks() {
    // 为设备列表更新设置回调
    let device_list_log = Arc::new(Mutex::new(Vec::new()));
    let device_list_log_clone = Arc::clone(&device_list_log);
    let on_device_list_update = move |devices: Vec<ChannelDevice>| {
        let device_list_log_clone_inner = Arc::clone(&device_list_log_clone);
        tokio::spawn(async move {
            let mut log = device_list_log_clone_inner.lock().await;
            log.push(devices);
        });
    };

    // 为接收传输设置回调
    let transfer_log = Arc::new(Mutex::new(Vec::new()));
    let transfer_log_clone = Arc::clone(&transfer_log);
    let on_receive_transfer = move |from_device_id: String, encrypted_summary: String| {
        let transfer_log_clone_inner = Arc::clone(&transfer_log_clone);
        tokio::spawn(async move {
            let mut log = transfer_log_clone_inner.lock().await;
            log.push((from_device_id, encrypted_summary));
        });
    };

    // 模拟客户端 A 加入 channel 后收到的 DeviceListUpdate 消息
    let mock_device_a = ChannelDevice {
        device_id: "device_a_id".to_string(),
        user_info: SignerUser {
            pub_key: "pub_key_a".to_string(),
            username: "User A".to_string(),
            update_time: 1000,
            ..Default::default()
        },
    };
    let mock_device_b = ChannelDevice {
        device_id: "device_b_id".to_string(),
        user_info: SignerUser {
            pub_key: "pub_key_b".to_string(),
            username: "User B".to_string(),
            update_time: 1001,
            ..Default::default()
        },
    };
    let mock_devices = vec![mock_device_a, mock_device_b];

    // 调用回调函数 (模拟 SignerTransferClient 内部的行为)
    on_device_list_update(mock_devices.clone());

    // 等待异步操作完成
    tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;

    // 验证回调是否被调用
    {
        let log = device_list_log.lock().await;
        assert_eq!(log.len(), 1);
        assert_eq!(log[0], mock_devices);
    }

    // 模拟收到传输请求
    let mock_from_device_id = "device_a_id".to_string();
    let mock_encrypted_summary = "base64_encoded_summary_data".to_string();
    on_receive_transfer(mock_from_device_id.clone(), mock_encrypted_summary.clone());

    // 等待异步操作完成
    tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;

    // 验证传输回调是否被调用
    {
        let log = transfer_log.lock().await;
        assert_eq!(log.len(), 1);
        assert_eq!(log[0].0, mock_from_device_id);
        assert_eq!(log[0].1, mock_encrypted_summary);
    }
}

/// 单元测试：SignerTransferClient 消息序列化
///
/// 验证 ClientToTransferMessage 的序列化和反序列化是否正确。
/// 这确保了客户端和服务器之间可以正确地交换消息。
#[test]
fn test_message_serialization() {
    let user_info = SignerUser {
        pub_key: "test_pub_key".to_string(),
        username: "Test User".to_string(),
        update_time: 1234567890,
        servers: vec![SignerServer {
            addr: "https://example.com/api".to_string(),
        }],
        ..Default::default()
    };

    // 测试 JoinChannel 消息 (创建新 channel)
    let join_msg_create = ClientToTransferMessage::JoinChannel {
        channel_id: None,
        user_info: user_info.clone(),
    };
    let serialized_create =
        serde_json::to_string(&join_msg_create).expect("序列化 JoinChannel (创建) 消息失败");
    let deserialized_create: ClientToTransferMessage =
        serde_json::from_str(&serialized_create).expect("反序列化 JoinChannel (创建) 消息失败");
    assert_eq!(join_msg_create, deserialized_create);

    // 测试 JoinChannel 消息 (加入现有 channel)
    let join_msg_join = ClientToTransferMessage::JoinChannel {
        channel_id: Some("channel_123".to_string()),
        user_info: user_info.clone(),
    };
    let serialized_join =
        serde_json::to_string(&join_msg_join).expect("序列化 JoinChannel (加入) 消息失败");
    let deserialized_join: ClientToTransferMessage =
        serde_json::from_str(&serialized_join).expect("反序列化 JoinChannel (加入) 消息失败");
    assert_eq!(join_msg_join, deserialized_join);

    // 测试 AcceptTransfer 消息
    let accept_msg = ClientToTransferMessage::AcceptTransfer {
        target_device_id: "device_456".to_string(),
        encrypted_summary: SignerCrypted {
            sender_pub_key: format!("sender_pub_key"),
            receiver_pub_key: format!("receiver_pub_key"),
            cipher_text: format!("cipher_text"),
            nonce: format!("nonce"),
            _marker: std::marker::PhantomData,
        },
    };
    let serialized_accept =
        serde_json::to_string(&accept_msg).expect("序列化 AcceptTransfer 消息失败");
    let deserialized_accept: ClientToTransferMessage =
        serde_json::from_str(&serialized_accept).expect("反序列化 AcceptTransfer 消息失败");
    assert_eq!(accept_msg, deserialized_accept);

    // 测试 TransferToClientMessage 的序列化和反序列化
    let channel_device = ChannelDevice {
        device_id: "device_789".to_string(),
        user_info: user_info.clone(),
    };

    // 测试 ChannelJoined 消息
    let channel_joined_msg = TransferToClientMessage::ChannelJoined {
        channel_id: "channel_123".to_string(),
        devices: vec![channel_device.clone()],
    };
    let serialized_joined =
        serde_json::to_string(&channel_joined_msg).expect("序列化 ChannelJoined 消息失败");
    let deserialized_joined: TransferToClientMessage =
        serde_json::from_str(&serialized_joined).expect("反序列化 ChannelJoined 消息失败");
    assert_eq!(channel_joined_msg, deserialized_joined);

    // 测试 DeviceListUpdate 消息
    let device_list_update_msg = TransferToClientMessage::DeviceListUpdate {
        devices: vec![channel_device.clone()],
    };
    let serialized_update =
        serde_json::to_string(&device_list_update_msg).expect("序列化 DeviceListUpdate 消息失败");
    let deserialized_update: TransferToClientMessage =
        serde_json::from_str(&serialized_update).expect("反序列化 DeviceListUpdate 消息失败");
    assert_eq!(device_list_update_msg, deserialized_update);

    // 测试 TransferStarted 消息
    let transfer_started_msg = TransferToClientMessage::TransferStarted {
        target_device_id: "device_456".to_string(),
    };
    let serialized_started =
        serde_json::to_string(&transfer_started_msg).expect("序列化 TransferStarted 消息失败");
    let deserialized_started: TransferToClientMessage =
        serde_json::from_str(&serialized_started).expect("反序列化 TransferStarted 消息失败");
    assert_eq!(transfer_started_msg, deserialized_started);

    // 测试 ReceiveTransfer 消息
    let receive_transfer_msg = TransferToClientMessage::ReceiveTransfer {
        from_device_id: "device_123".to_string(),
        encrypted_summary: SignerCrypted {
            sender_pub_key: format!("sender_pub_key"),
            receiver_pub_key: format!("receiver_pub_key"),
            cipher_text: format!("cipher_text"),
            nonce: format!("nonce"),
            _marker: std::marker::PhantomData,
        },
    };
    let serialized_receive =
        serde_json::to_string(&receive_transfer_msg).expect("序列化 ReceiveTransfer 消息失败");
    let deserialized_receive: TransferToClientMessage =
        serde_json::from_str(&serialized_receive).expect("反序列化 ReceiveTransfer 消息失败");
    assert_eq!(receive_transfer_msg, deserialized_receive);
}