test: add unit tests to improve coverage from 42% to 50%

Add new test files:
- tests/unit/builder.rs - MessageBuilder tests (0% → 100%)
- tests/unit/subscriptions_legacy.rs - SubscriptionChannel tests (0% → 100%)
- tests/unit/notification.rs - NotificationHandler tests (11% → 100%)
- tests/unit/response.rs - ResponseHandler tests (12% → 100%)

Update existing tests:
- tests/unit/session.rs - WebSocketSession async tests (17% → 100%)
- tests/unit/config.rs - Builder methods tests (58% → 98%)

Coverage improved from 42.70% to 50.62% (+7.92%)

Author: joaquinbejar

tests/unit/builder.rs

@@ -0,0 +1,123 @@
+//! Unit tests for message/builder.rs
+
+use deribit_websocket::message::{MessageBuilder, MessageType};
+
+#[test]
+fn test_message_builder_new() {
+    let builder = MessageBuilder::new();
+    // Verify builder is created successfully
+    assert!(format!("{:?}", builder).contains("MessageBuilder"));
+}
+
+#[test]
+fn test_message_builder_default() {
+    let builder = MessageBuilder::default();
+    assert!(format!("{:?}", builder).contains("MessageBuilder"));
+}
+
+#[test]
+fn test_message_builder_request_builder() {
+    let mut builder = MessageBuilder::new();
+    let request_builder = builder.request_builder();
+    // Verify we can access the request builder
+    assert!(format!("{:?}", request_builder).contains("RequestBuilder"));
+}
+
+#[test]
+fn test_message_builder_response_handler() {
+    let builder = MessageBuilder::new();
+    let response_handler = builder.response_handler();
+    assert!(format!("{:?}", response_handler).contains("ResponseHandler"));
+}
+
+#[test]
+fn test_message_builder_notification_handler() {
+    let builder = MessageBuilder::new();
+    let notification_handler = builder.notification_handler();
+    assert!(format!("{:?}", notification_handler).contains("NotificationHandler"));
+}
+
+#[test]
+fn test_parse_message_response() {
+    let builder = MessageBuilder::new();
+    
+    let response_json = r#"{
+        "jsonrpc": "2.0",
+        "id": 1,
+        "result": {"version": "1.2.26"}
+    }"#;
+    
+    let result = builder.parse_message(response_json);
+    assert!(result.is_ok());
+    
+    if let Ok(MessageType::Response(response)) = result {
+        assert_eq!(response.id.as_u64().unwrap(), 1);
+    } else {
+        panic!("Expected Response message type");
+    }
+}
+
+#[test]
+fn test_parse_message_notification() {
+    let builder = MessageBuilder::new();
+    
+    let notification_json = r#"{
+        "jsonrpc": "2.0",
+        "method": "subscription",
+        "params": {
+            "channel": "ticker.BTC-PERPETUAL",
+            "data": {"price": 50000}
+        }
+    }"#;
+    
+    let result = builder.parse_message(notification_json);
+    assert!(result.is_ok());
+    
+    if let Ok(MessageType::Notification(notification)) = result {
+        assert_eq!(notification.method, "subscription");
+    } else {
+        panic!("Expected Notification message type");
+    }
+}
+
+#[test]
+fn test_parse_message_invalid() {
+    let builder = MessageBuilder::new();
+    
+    let invalid_json = r#"not valid json"#;
+    
+    let result = builder.parse_message(invalid_json);
+    assert!(result.is_err());
+}
+
+#[test]
+fn test_message_type_debug() {
+    let builder = MessageBuilder::new();
+    
+    let response_json = r#"{
+        "jsonrpc": "2.0",
+        "id": 1,
+        "result": {"version": "1.2.26"}
+    }"#;
+    
+    if let Ok(msg_type) = builder.parse_message(response_json) {
+        let debug_str = format!("{:?}", msg_type);
+        assert!(debug_str.contains("Response"));
+    }
+}
+
+#[test]
+fn test_message_type_clone() {
+    let builder = MessageBuilder::new();
+    
+    let response_json = r#"{
+        "jsonrpc": "2.0",
+        "id": 1,
+        "result": {"version": "1.2.26"}
+    }"#;
+    
+    if let Ok(msg_type) = builder.parse_message(response_json) {
+        let cloned = msg_type.clone();
+        assert!(format!("{:?}", cloned).contains("Response"));
+    }
+}

tests/unit/config.rs

@@ -88,3 +88,89 @@ fn test_config_debug() {
     assert!(debug_str.contains("ws_url"));
     assert!(debug_str.contains("heartbeat_interval"));
 }
+
+#[test]
+fn test_config_with_connection_timeout() {
+    let config = WebSocketConfig::default()
+        .with_connection_timeout(Duration::from_secs(120));
+
+    assert_eq!(config.connection_timeout, Duration::from_secs(120));
+}
+
+#[test]
+fn test_config_with_credentials() {
+    let config = WebSocketConfig::default()
+        .with_credentials("client_id".to_string(), "client_secret".to_string());
+
+    assert_eq!(config.client_id, Some("client_id".to_string()));
+    assert_eq!(config.client_secret, Some("client_secret".to_string()));
+}
+
+#[test]
+fn test_config_with_client_id() {
+    let config = WebSocketConfig::default()
+        .with_client_id("my_client_id".to_string());
+
+    assert_eq!(config.client_id, Some("my_client_id".to_string()));
+}
+
+#[test]
+fn test_config_with_client_secret() {
+    let config = WebSocketConfig::default()
+        .with_client_secret("my_secret".to_string());
+
+    assert_eq!(config.client_secret, Some("my_secret".to_string()));
+}
+
+#[test]
+fn test_config_with_logging() {
+    let config = WebSocketConfig::default()
+        .with_logging(true);
+
+    assert!(config.enable_logging);
+}
+
+#[test]
+fn test_config_with_logging_disabled() {
+    let config = WebSocketConfig::default()
+        .with_logging(false);
+
+    assert!(!config.enable_logging);
+}
+
+#[test]
+fn test_config_with_log_level() {
+    let config = WebSocketConfig::default()
+        .with_log_level("debug".to_string());
+
+    assert_eq!(config.log_level, "debug");
+}
+
+#[test]
+fn test_config_with_test_mode() {
+    let config = WebSocketConfig::default()
+        .with_test_mode(true);
+
+    assert!(config.test_mode);
+}
+
+#[test]
+fn test_config_has_credentials_true() {
+    let config = WebSocketConfig::default()
+        .with_credentials("client_id".to_string(), "client_secret".to_string());
+
+    assert!(config.has_credentials());
+}
+
+#[test]
+fn test_config_get_credentials_some() {
+    let config = WebSocketConfig::default()
+        .with_credentials("client_id".to_string(), "client_secret".to_string());
+
+    let creds = config.get_credentials();
+    assert!(creds.is_some());
+
+    let (id, secret) = creds.unwrap();
+    assert_eq!(id, "client_id");
+    assert_eq!(secret, "client_secret");
+}

tests/unit/mod.rs

@@ -4,15 +4,19 @@
 //! Each submodule tests a specific component of the WebSocket client.
 
 pub mod account;
+pub mod builder;
 pub mod callback;
 pub mod client;
 pub mod config;
 pub mod connection;
 pub mod error;
 pub mod message;
 pub mod model;
+pub mod notification;
 pub mod position;
+pub mod response;
 pub mod session;
 pub mod subscription_channel;
 pub mod subscriptions;
+pub mod subscriptions_legacy;
 pub mod trading;