Struct SteamClientBuilder 

pub struct SteamClientBuilder { /* private fields */ }

Builder for creating SteamClient instances with customized dependencies.

Use this builder when you need to inject mock implementations for testing or customize the behavior of the Steam client.

Testing Example

use steam_client::{SteamClient, SteamClientBuilder};

// Create a test client with mocked dependencies
let (client, mocks) = SteamClient::builder().with_mock_http().build_with_mocks();

assert!(!client.is_logged_in());

Production Example

use steam_client::{SteamClient, SteamOptions};

// For production, just use SteamClient::new()
let client = SteamClient::new(SteamOptions::default());

Implementations

impl SteamClientBuilder

pub fn new() -> Self

Create a new builder with default settings.

The default configuration uses:

• SteamOptions::default()
• HttpCmServerProvider::new_default()
• ReqwestHttpClient (lazy initialized in build)
• SystemClock (lazy initialized in build)
• ThreadRng (lazy initialized in build)

pub fn with_options(self, options: SteamOptions) -> Self

Set the options for the Steam client.

These options control high-level behavior like auto-relogin, proxy settings, and connection protocols.

If not called, the client will be built using SteamOptions::default().

pub fn with_http_client(self, client: Arc<dyn HttpClient>) -> Self

Use a custom HTTP client.

This is useful for providing a custom-configured reqwest client or a completely different implementation of the HttpClient trait.

pub fn with_mock_http(self) -> Self

Use a mock HTTP client for testing.

Returns a client that records requests and returns queued responses. Use build_with_mocks() to get access to the mock for test assertions.

pub fn with_mock_http_responses(self, responses: Vec<HttpResponse>) -> Self

Use a mock HTTP client with pre-queued responses.

This is a convenience method for short tests that only need to verify sequence of HTTP responses.

pub fn with_clock(self, clock: Arc<dyn Clock>) -> Self

Use a custom clock.

The clock is used for timing heartbeats, measuring timeouts, and other time-sensitive logic.

pub fn with_mock_clock(self) -> Self

Use a mock clock for testing.

The mock clock starts at time zero and can be advanced manually. Use build_with_mocks() to get access to the mock for time control.

pub fn with_rng(self, rng: Arc<dyn Rng>) -> Self

Use a custom random number generator.

The RNG is used for generating session IDs, encryption keys, and other randomized values.

pub fn with_mock_rng(self) -> Self

Use a mock RNG for testing.

The mock RNG returns deterministic values that can be set. Use build_with_mocks() to get access to the mock for value control.

pub fn with_mock_rng_values( self, usize_val: usize, i32_val: i32, u32_val: u32, ) -> Self

Use a mock RNG with specific initial values.

Provides deterministic values for usize, i32, and u32 requests.

pub fn with_all_mocks(self) -> Self

Configure all other dependencies with mock implementations.

Equivalent to calling with_mock_http(), with_mock_clock(), and with_mock_rng().

pub fn build(self) -> SteamClient

Build the SteamClient instance.

• Clock: SystemClock
• RNG: ThreadRng
• CM Provider: [HttpCmServerProvider]

pub fn build_with_mocks(self) -> (SteamClient, MockHandles)

Build the SteamClient and return handles to any mock dependencies.

This is useful in tests where you need to control mock behavior or inspect recorded interactions.

Example

use std::time::Duration;

use steam_client::{utils::http::HttpResponse, SteamClient};

let (client, mocks) = SteamClient::builder()
    .with_mock_http()
    .with_mock_clock()
    .build_with_mocks();

// Control the mock clock
if let Some(clock) = &mocks.clock {
    clock.advance(Duration::from_secs(10));
}

// Inspect HTTP requests
if let Some(http) = &mocks.http {
    assert_eq!(http.request_count(), 0);
}

Trait Implementations

impl Default for SteamClientBuilder

fn default() -> Self

Returns the “default value” for a type.