#[cfg(test)]
mod unit_tests {
    use super::*;
    use serde_json::json;
    use std::sync::Arc;
    use parking_lot::RwLock;
    use std::collections::HashMap;

    #[test]
    fn test_index_operations() {
        let indexes = Arc::new(RwLock::new(HashMap::new()));
        let key = "test_key".to_string();
        let value = json!({"name": "test", "age": 30});

        // Создание индекса
        let create_cmd = Command::CreateIndex {
            field: "name".to_string(),
        };
        let server = create_test_server();
        let response = server.process_command_internal(create_cmd);
        assert!(matches!(response, Response::Success(None)));

        // Проверка что индекс создан
        {
            let indexes = server.indexes.read();
            assert!(indexes.contains_key("name"));
        }

        // Вставка данных для индексации
        let insert_cmd = Command::Insert {
            key: key.clone(),
            value: value.clone(),
        };
        let response = server.process_command_internal(insert_cmd);
        assert!(matches!(response, Response::Success(None)));

        // Проверка что данные проиндексированы
        {
            let indexes = server.indexes.read();
            let name_index = indexes.get("name").unwrap();
            assert!(name_index.contains_key(&json!("test")));
            assert_eq!(name_index[&json!("test")], vec!["test_key"]);
        }

        // Удаление индекса
        let drop_cmd = Command::DropIndex {
            field: "name".to_string(),
        };
        let response = server.process_command_internal(drop_cmd);
        assert!(matches!(response, Response::Success(None)));

        // Проверка что индекс удален
        {
            let indexes = server.indexes.read();
            assert!(!indexes.contains_key("name"));
        }
    }

    #[test]
    fn test_backup_operations() {
        let server = create_test_server();
        let temp_path = "test_backup.json";

        // Вставка тестовых данных
        let insert_cmd = Command::Insert {
            key: "backup_key".to_string(),
            value: json!({"backup": "test"}),
        };
        let response = server.process_command_internal(insert_cmd);
        assert!(matches!(response, Response::Success(None)));

        // Создание бэкапа
        let backup_cmd = Command::BackupCreate {
            path: temp_path.to_string(),
        };
        let response = server.process_command_internal(backup_cmd);
        assert!(matches!(response, Response::BackupStatus { success: true, .. }));

        // Очистка базы
        let delete_cmd = Command::Delete {
            key: "backup_key".to_string(),
        };
        let response = server.process_command_internal(delete_cmd);
        assert!(matches!(response, Response::Success(None)));

        // Восстановление из бэкапа
        let restore_cmd = Command::BackupRestore {
            path: temp_path.to_string(),
        };
        let response = server.process_command_internal(restore_cmd);
        assert!(matches!(response, Response::BackupStatus { success: true, .. }));

        // Проверка что данные восстановились
        let get_cmd = Command::Get {
            key: "backup_key".to_string(),
            version: None,
        };
        let response = server.process_command_internal(get_cmd);
        assert!(matches!(response, Response::Success(Some(_))));

        if let Response::Success(Some(value)) = response {
            assert_eq!(value, json!({"backup": "test"}));
        }

        // Удаление временного файла
        std::fs::remove_file(temp_path).unwrap();
    }

    #[test]
    fn test_replication_commands() {
        let server = create_test_server();

        // Проверка статуса репликации
        let status_cmd = Command::ReplicationStatus;
        let response = server.process_command_internal(status_cmd);
        assert!(matches!(response, Response::ReplicationStatus { .. }));

        // Добавление пира
        let add_peer_cmd = Command::ReplicationAddPeer {
            addr: "127.0.0.1:8081".to_string(),
        };
        let response = server.process_command_internal(add_peer_cmd);
        assert!(matches!(response, Response::Success(None)));

        // Проверка что пир добавился
        if let Response::ReplicationStatus { peers, .. } = server.process_command_internal(Command::ReplicationStatus) {
            assert!(peers.contains(&"127.0.0.1:8081".to_string()));
        }

        // Удаление пира
        let remove_peer_cmd = Command::ReplicationRemovePeer {
            addr: "127.0.0.1:8081".to_string(),
        };
        let response = server.process_command_internal(remove_peer_cmd);
        assert!(matches!(response, Response::Success(None)));

        // Проверка что пир удалился
        if let Response::ReplicationStatus { peers, .. } = server.process_command_internal(Command::ReplicationStatus) {
            assert!(!peers.contains(&"127.0.0.1:8081".to_string()));
        }
    }

    fn create_test_server() -> FutriixServer {
        FutriixServer {
            db: Arc::new(RwLock::new(HashMap::new())),
            time_series_db: Arc::new(RwLock::new(HashMap::new())),
            command_queue: Arc::new(SegQueue::new()),
            transactions: Arc::new(RwLock::new(HashMap::new())),
            indexes: Arc::new(RwLock::new(HashMap::new())),
            replication_enabled: false,
            peer_nodes: Vec::new(),
            sync_interval: 1000,
            last_sync_timestamp: Arc::new(RwLock::new(0)),
            command_history: Arc::new(RwLock::new(Vec::new())),
            next_tx_id: Arc::new(RwLock::new(1)),
        }
    }
}