test: add integration tests for long worker name truncation

Author: average-gary

integration-tests/tests/translator_integration.rs

@@ -1473,3 +1473,218 @@ async fn aggregated_translator_triggers_fallback_on_close_channel_message() {
         .wait_for_message_type(MessageDirection::ToUpstream, MESSAGE_TYPE_SETUP_CONNECTION)
         .await;
 }
+
+/// This test verifies that the translator correctly handles miners with long worker names.
+///
+/// The UserIdentity TLV field has a 32-byte limit. When a miner sends mining.authorize with
+/// a long "username.workername", the translator should:
+/// - Truncate the total identity to 32 bytes (preserving the username prefix)
+/// - Continue processing shares without panicking
+///
+/// This test uses a short username with a very long worker name to verify truncation works.
+#[tokio::test]
+async fn translator_handles_long_worker_name_with_truncation() {
+    start_tracing();
+    let (_tp, tp_addr) = start_template_provider(None, DifficultyLevel::Low);
+    let (_pool, pool_addr) = start_pool(sv2_tp_config(tp_addr), vec![], vec![]).await;
+    let (pool_translator_sniffer, pool_translator_sniffer_addr) =
+        start_sniffer("0", pool_addr, false, vec![], None);
+
+    // Start translator in non-aggregated mode (needed for user identity TLV)
+    let (_, tproxy_addr) =
+        start_sv2_translator(&[pool_translator_sniffer_addr], false, vec![], vec![], None).await;
+
+    // Use a short username (8 chars) with a very long worker name (50+ chars)
+    // Total: "shortusr.very_long_worker_name_that_exceeds_32_bytes_limit_easily" = 65 chars
+    // This should be truncated to 32 bytes but still work
+    let long_worker_name = Some("shortuser.very_long_worker_name_that_exceeds_limit".to_string());
+
+    let (_minerd_process, _minerd_addr) =
+        start_minerd(tproxy_addr, long_worker_name, Some("x".to_string()), false).await;
+
+    // Verify the translator doesn't panic and can successfully:
+    // 1. Complete setup connection
+    pool_translator_sniffer
+        .wait_for_message_type(MessageDirection::ToUpstream, MESSAGE_TYPE_SETUP_CONNECTION)
+        .await;
+    pool_translator_sniffer
+        .wait_for_message_type(
+            MessageDirection::ToDownstream,
+            MESSAGE_TYPE_SETUP_CONNECTION_SUCCESS,
+        )
+        .await;
+
+    // 2. Open a mining channel
+    pool_translator_sniffer
+        .wait_for_message_type(
+            MessageDirection::ToUpstream,
+            MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL,
+        )
+        .await;
+    pool_translator_sniffer
+        .wait_for_message_type(
+            MessageDirection::ToDownstream,
+            MESSAGE_TYPE_OPEN_EXTENDED_MINING_CHANNEL_SUCCESS,
+        )
+        .await;
+
+    // 3. Receive a job
+    pool_translator_sniffer
+        .wait_for_message_type(
+            MessageDirection::ToDownstream,
+            MESSAGE_TYPE_NEW_EXTENDED_MINING_JOB,
+        )
+        .await;
+
+    // 4. Submit shares without panicking (this is the critical part -
+    //    before the fix, this would panic with "UserIdentity exceeds 32 bytes")
+    pool_translator_sniffer
+        .wait_for_message_type(
+            MessageDirection::ToUpstream,
+            MESSAGE_TYPE_SUBMIT_SHARES_EXTENDED,
+        )
+        .await;
+}
+
+/// This test verifies that the translator rejects mining.authorize when the username
+/// portion (before the '.') exceeds 32 bytes.
+///
+/// The UserIdentity TLV field has a 32-byte limit. When a miner sends mining.authorize with
+/// a username that exceeds this limit, the translator should reject the authorize request
+/// by returning false, rather than accepting it and later panicking during share submission.
+///
+/// This test uses a username that is 40 characters long (exceeds 32 byte limit).
+#[tokio::test]
+async fn translator_rejects_authorize_with_username_exceeding_32_bytes() {
+    start_tracing();
+    let (_tp, tp_addr) = start_template_provider(None, DifficultyLevel::Low);
+    let (_pool, pool_addr) = start_pool(sv2_tp_config(tp_addr), vec![], vec![]).await;
+    let (_pool_translator_sniffer, pool_translator_sniffer_addr) =
+        start_sniffer("0", pool_addr, false, vec![], None);
+
+    // Start translator in non-aggregated mode
+    let (_, tproxy_addr) =
+        start_sv2_translator(&[pool_translator_sniffer_addr], false, vec![], vec![], None).await;
+
+    // Start SV1 sniffer to intercept mining.authorize request and response
+    let (sv1_sniffer, sv1_sniffer_addr) = start_sv1_sniffer(tproxy_addr);
+
+    // Use a username that exceeds 32 bytes (40 chars) - this should be rejected
+    // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa.worker" = 40 char username
+    let long_username = Some("a".repeat(40) + ".worker");
+
+    let (_minerd_process, _minerd_addr) = start_minerd(
+        sv1_sniffer_addr,
+        long_username,
+        Some("x".to_string()),
+        false,
+    )
+    .await;
+
+    // Wait for the mining.authorize request from downstream (miner -> translator)
+    sv1_sniffer
+        .wait_for_message(&["mining.authorize"], MessageDirection::ToUpstream)
+        .await;
+
+    // Wait for the mining.authorize response from translator (translator -> miner)
+    // The response contains "result": false when authorization is rejected
+    // We search for "false" in the response which indicates rejection
+    sv1_sniffer
+        .wait_for_message(&["false"], MessageDirection::ToDownstream)
+        .await;
+
+    // Verify the response was indeed a rejection by checking for the authorize response
+    // The SV1 sniffer has captured the OkResponse with result: false
+    sv1_sniffer
+        .wait_and_assert(
+            SV1MessageFilter::WithMessageId(2), // mining.authorize is typically id=2 (after subscribe=1)
+            MessageDirection::ToDownstream,
+            |msg| {
+                if let sv1_api::Message::OkResponse(res) = msg {
+                    // The result should be false (authorization rejected)
+                    assert_eq!(
+                        res.result,
+                        corepc_node::serde_json::Value::Bool(false),
+                        "Expected mining.authorize to return false for username exceeding 32 bytes"
+                    );
+                } else {
+                    panic!("Expected OkResponse for mining.authorize, got {:?}", msg);
+                }
+            },
+        )
+        .await;
+}
+
+/// This test demonstrates that a miner with a valid short username (under 32 bytes)
+/// but a long worker name gets authorized successfully, with the worker name truncated.
+///
+/// Contrast with `translator_rejects_authorize_with_username_exceeding_32_bytes` which
+/// shows that a long username (before the '.') causes rejection.
+#[tokio::test]
+async fn translator_accepts_authorize_with_short_username_long_worker() {
+    start_tracing();
+    let (_tp, tp_addr) = start_template_provider(None, DifficultyLevel::Low);
+    let (_pool, pool_addr) = start_pool(sv2_tp_config(tp_addr), vec![], vec![]).await;
+    let (_pool_translator_sniffer, pool_translator_sniffer_addr) =
+        start_sniffer("0", pool_addr, false, vec![], None);
+
+    // Start translator in non-aggregated mode
+    let (_, tproxy_addr) =
+        start_sv2_translator(&[pool_translator_sniffer_addr], false, vec![], vec![], None).await;
+
+    // Start SV1 sniffer to intercept mining.authorize response
+    let (sv1_sniffer, sv1_sniffer_addr) = start_sv1_sniffer(tproxy_addr);
+
+    // Use a short username (10 chars) with a very long worker name (50 chars)
+    // Total = 61 chars, but username is only 10, so it should be accepted (and truncated)
+    let short_user_long_worker =
+        Some("shortuser1.this_is_a_very_long_worker_name_exceeding_limit".to_string());
+
+    let (_minerd_process, _minerd_addr) = start_minerd(
+        sv1_sniffer_addr,
+        short_user_long_worker,
+        Some("x".to_string()),
+        false,
+    )
+    .await;
+
+    // Wait for the mining.authorize request
+    sv1_sniffer
+        .wait_for_message(&["mining.authorize"], MessageDirection::ToUpstream)
+        .await;
+
+    // Wait for the mining.authorize response and verify it returns true (accepted)
+    // despite the total length exceeding 32 bytes (only the username matters for validation)
+    sv1_sniffer
+        .wait_for_message(&["true"], MessageDirection::ToDownstream)
+        .await;
+
+    // Verify the response was indeed an acceptance
+    sv1_sniffer
+        .wait_and_assert(
+            SV1MessageFilter::WithMessageId(2), // mining.authorize is typically id=2
+            MessageDirection::ToDownstream,
+            |msg| {
+                if let sv1_api::Message::OkResponse(res) = msg {
+                    // The result should be true (authorization accepted)
+                    assert_eq!(
+                        res.result,
+                        corepc_node::serde_json::Value::Bool(true),
+                        "Expected mining.authorize to return true for short username"
+                    );
+                } else {
+                    panic!("Expected OkResponse for mining.authorize, got {:?}", msg);
+                }
+            },
+        )
+        .await;
+
+    // Wait for mining.notify which proves the miner was successfully authorized
+    // and received a job
+    sv1_sniffer
+        .wait_for_message(&["mining.notify"], MessageDirection::ToDownstream)
+        .await;
+
+    // If we get here without the translator panicking, the test passes.
+    // The worker name was truncated (logged as warning) but mining continues.
+}