juspay/hyperswitch · error

failed to subscribe on authenticated connection

Error message

failed to subscribe on authenticated connection

What it means

Panic from expect() on subscriber.subscribe(&channel).await in test_authenticated_connection_pubsub (crates/redis_interface/src/test.rs:2379). The RedisInterface subscriber (pubsub connection) failed to issue SUBSCRIBE on the channel over the authenticated connection, so the future returned Err and the test aborts with this message. It means the dedicated pubsub connection could not be established or the SUBSCRIBE command was rejected.

Solutions

1. Ensure the base authenticated connection works first (other tests in the suite pass); fix credentials/host if the pool itself can't authenticate.
2. If using Redis cluster, subscribe on the node that owns the channel's keyslot or enable cluster-aware pubsub routing in the subscriber.
3. Create the subscriber/pool immediately before subscribing and add a small sleep so the pubsub task is connected before subscribe() is called.
4. Inspect the underlying redis error (subscribe returns the raw error) — match on it to distinguish auth vs network vs protocol issues instead of a bare expect.

Example fix

// before
pool.redis_conn
    .subscriber
    .subscribe(&channel)
    .await
    .expect("failed to subscribe on authenticated connection");
// after
pool.redis_conn
    .subscriber
    .subscribe(&channel)
    .await
    .unwrap_or_else(|e| panic!("failed to subscribe on {channel}: {e:?}"));

// before subscribing, confirm a plain connection works:
// let mut conn = pool.redis_conn.publisher.clone();
// redis::cmd("PING").query_async::<()>(&mut conn).await.expect("ping failed");

pool.redis_conn.subscriber.subscribe(&channel).await
    .unwrap_or_else(|e| panic!("failed to subscribe on {channel}: {e:?}"));

When it happens

Trigger: Calling pool.redis_conn.subscriber.subscribe(&channel) when the pubsub connection can't be created (auth failure, unreachable server), or Redis rejects the subscribe (e.g. running against a cluster where the node mapping fails, or the connection is in an invalid state after an error).

Common situations: Authenticated Redis misconfigured (wrong password so pubsub reconnect fails); cluster mode with channel-keyslot restrictions; pubsub connection dropped by server timeout before subscribe; tests running without Redis so the subscriber pool init fails.

Understand the failure class

Background: ECONNREFUSED and "connection refused" / "could not connect to server" errors: what they mean and how to fix them — this error's family across 44 libraries.

• Authentication and authorization failures — expired tokens, bad credentials, and missing scopes.

Related errors

• failed to publish on authenticated connection
• failed to connect to authenticated redis
• Spawn block failure
• authenticated redis settings failed validation
• todo!()

AI-assisted analysis of juspay/hyperswitch@afd9284352 (2026-09-18). Data as JSON: /api/errors/4cdb2f6665b44df0. Report an issue: GitHub.

Appendix: source

Thrown at crates/redis_interface/src/test.rs:2379

}

#[tokio::test]
async fn test_authenticated_connection_pubsub() {
    let is_success = tokio::task::spawn_blocking(move || {
        futures::executor::block_on(async {
            let Some(pool) = get_auth_pool_or_skip().await else {
                tracing::warn!("SKIP: auth test skipped — set TEST_REDIS_AUTH_PASSWORD to enable");
                return true;
            };

            let channel = format!("test_auth_pubsub_{}", unique_test_id());
            let test_message = "authenticated_message";

            pool.redis_conn
                .subscriber
                .subscribe(&channel)
                .await
                .expect("failed to subscribe on authenticated connection");

            let mut receiver = pool.redis_conn.subscriber.message_rx();

            tokio::time::sleep(std::time::Duration::from_millis(100)).await;

            pool.redis_conn
                .publisher
                .publish(&channel, RedisValue::from_string(test_message.to_string()))
                .await
                .expect("failed to publish on authenticated connection");

            let received =
                tokio::time::timeout(std::time::Duration::from_secs(5), receiver.recv()).await;

            match received {
                Ok(Ok(msg)) => {
                    let value_str = redis_value_to_option_string(&msg.value);
                    msg.channel == channel && value_str.as_deref() == Some(test_message)

View on GitHub (pinned to afd9284352)