Struct MockDevice

pub struct MockDevice { /* private fields */ }

A mock Aranet device for testing.

Implements AranetDevice trait for use in generic code and testing.

Example

use aranet_core::{MockDevice, AranetDevice};
use aranet_types::DeviceType;

#[tokio::main]
async fn main() {
    let device = MockDevice::new("Test", DeviceType::Aranet4);
    device.connect().await.unwrap();

    // Can use through trait
    async fn read_via_trait<D: AranetDevice>(d: &D) {
        let _ = d.read_current().await;
    }
    read_via_trait(&device).await;
}

Implementations

impl MockDevice

pub fn new(name: &str, device_type: DeviceType) -> Self

Create a new mock device with default values.

pub async fn connect(&self) -> Result<()>

Connect to the mock device.

pub async fn disconnect(&self) -> Result<()>

Disconnect from the mock device.

pub fn is_connected_sync(&self) -> bool

Check if connected (sync method for internal use).

pub fn name(&self) -> &str

Get the device name.

pub fn address(&self) -> &str

Get the device address.

pub fn device_type(&self) -> DeviceType

Get the device type.

pub async fn read_current(&self) -> Result<CurrentReading>

Read current sensor values.

pub async fn read_battery(&self) -> Result<u8>

Read battery level.

pub async fn read_rssi(&self) -> Result<i16>

Read RSSI (signal strength).

pub async fn read_device_info(&self) -> Result<DeviceInfo>

Read device info.

pub async fn get_history_info(&self) -> Result<HistoryInfo>

Get history info.

pub async fn download_history(&self) -> Result<Vec<HistoryRecord>>

Download history.

pub async fn download_history_with_options( &self, options: HistoryOptions, ) -> Result<Vec<HistoryRecord>>

Download history with options.

pub async fn get_interval(&self) -> Result<MeasurementInterval>

Get the measurement interval.

pub async fn set_interval(&self, interval: MeasurementInterval) -> Result<()>

Set the measurement interval.

pub async fn get_calibration(&self) -> Result<CalibrationData>

Get calibration data.

pub async fn set_reading(&self, reading: CurrentReading)

Set the current reading for testing.

pub async fn set_co2(&self, co2: u16)

Set CO2 level directly.

pub async fn set_temperature(&self, temp: f32)

Set temperature directly.

pub async fn set_battery(&self, level: u8)

Set battery level.

pub async fn set_radon(&self, radon: u32)

Set radon concentration in Bq/m³ (AranetRn+ devices).

pub async fn set_radon_averages(&self, avg_24h: u32, avg_7d: u32, avg_30d: u32)

Set radon averages (AranetRn+ devices).

pub async fn set_radiation(&self, rate: f32, total: f64)

Set radiation values (Aranet Radiation devices).

pub fn set_rssi(&self, rssi: i16)

Set RSSI (signal strength) for testing.

pub async fn add_history(&self, records: Vec<HistoryRecord>)

Add history records.

pub async fn set_should_fail(&self, fail: bool, message: Option<&str>)

Make the device fail on next operation.

pub fn read_count(&self) -> u32

Get the number of read operations performed.

pub fn reset_read_count(&self)

Reset read count.

pub fn set_read_latency(&self, latency: Duration)

Set simulated read latency.

Each read operation will be delayed by this duration. Set to Duration::ZERO to disable latency simulation.

pub fn set_connect_latency(&self, latency: Duration)

Set simulated connect latency.

Connect operations will be delayed by this duration. Set to Duration::ZERO to disable latency simulation.

pub fn set_transient_failures(&self, count: u32)

Configure transient failures.

The device will fail the next count operations, then succeed. This is useful for testing retry logic.

Example

use aranet_core::MockDevice;
use aranet_types::DeviceType;

let device = MockDevice::new("Test", DeviceType::Aranet4);
// First 3 connect attempts will fail, 4th will succeed
device.set_transient_failures(3);

pub fn reset_transient_failures(&self)

Reset transient failure counter.

pub fn remaining_failures(&self) -> u32

Get the number of remaining transient failures.

Trait Implementations

impl AranetDevice for MockDevice

fn is_connected<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Check if the device is connected.

fn disconnect<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Disconnect from the device.

fn name(&self) -> Option<&str>

Get the device name, if available.

fn address(&self) -> &str

Get the device address or identifier.

fn device_type(&self) -> Option<DeviceType>

Get the detected device type, if available.

fn read_current<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CurrentReading>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read the current sensor values.

fn read_device_info<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<DeviceInfo>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read device information (model, serial, firmware version, etc.).

fn read_rssi<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<i16>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read the current RSSI (signal strength) in dBm.

fn read_battery<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u8>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read the battery level (0-100).

fn get_history_info<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HistoryInfo>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get information about stored history.

fn download_history<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<HistoryRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Download all historical readings.

fn download_history_with_options<'life0, 'async_trait>( &'life0 self, options: HistoryOptions, ) -> Pin<Box<dyn Future<Output = Result<Vec<HistoryRecord>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Download historical readings with custom options.

fn get_interval<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<MeasurementInterval>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get the current measurement interval.

fn set_interval<'life0, 'async_trait>( &'life0 self, interval: MeasurementInterval, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Set the measurement interval.

fn get_calibration<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CalibrationData>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Read calibration data from the device.

fn connect<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Connect to the device.

impl Debug for MockDevice

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.