aranet_core/

mock.rs

//! Mock device implementation for testing.
//!
//! This module provides a mock device that can be used for unit testing
//! without requiring actual BLE hardware.
//!
//! The [`MockDevice`] implements the [`AranetDevice`] trait, allowing it to be
//! used interchangeably with real devices in generic code.
//!
//! # Features
//!
//! - **Failure injection**: Set the device to fail on specific operations
//! - **Latency simulation**: Add artificial delays to simulate slow BLE responses
//! - **Custom behavior**: Inject custom reading generators for dynamic test scenarios

use std::sync::atomic::{AtomicBool, AtomicI16, AtomicU32, AtomicU64, Ordering};
use std::time::Duration;

use async_trait::async_trait;
use tokio::sync::RwLock;

use aranet_types::{CurrentReading, DeviceInfo, DeviceType, HistoryRecord, Status};

use crate::error::{Error, Result};
use crate::history::{HistoryInfo, HistoryOptions};
use crate::settings::{CalibrationData, MeasurementInterval};
use crate::traits::AranetDevice;

/// 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;
/// }
/// ```
pub struct MockDevice {
    name: String,
    address: String,
    device_type: DeviceType,
    connected: AtomicBool,
    current_reading: RwLock<CurrentReading>,
    device_info: RwLock<DeviceInfo>,
    history: RwLock<Vec<HistoryRecord>>,
    interval: RwLock<MeasurementInterval>,
    calibration: RwLock<CalibrationData>,
    battery: RwLock<u8>,
    rssi: AtomicI16,
    read_count: AtomicU32,
    should_fail: AtomicBool,
    fail_message: RwLock<String>,
    /// Simulated read latency in milliseconds (0 = no delay).
    read_latency_ms: AtomicU64,
    /// Simulated connect latency in milliseconds (0 = no delay).
    connect_latency_ms: AtomicU64,
    /// Number of operations to fail before succeeding (0 = always succeed/fail based on should_fail).
    fail_count: AtomicU32,
    /// Current count of failures (decremented on each failure).
    remaining_failures: AtomicU32,
}

impl std::fmt::Debug for MockDevice {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("MockDevice")
            .field("name", &self.name)
            .field("address", &self.address)
            .field("device_type", &self.device_type)
            .field("connected", &self.connected.load(Ordering::Relaxed))
            .finish()
    }
}

impl MockDevice {
    /// Create a new mock device with default values.
    pub fn new(name: &str, device_type: DeviceType) -> Self {
        Self {
            name: name.to_string(),
            address: format!("MOCK-{:06X}", rand::random::<u32>() % 0xFFFFFF),
            device_type,
            connected: AtomicBool::new(false),
            current_reading: RwLock::new(Self::default_reading()),
            device_info: RwLock::new(Self::default_info(name)),
            history: RwLock::new(Vec::new()),
            interval: RwLock::new(MeasurementInterval::FiveMinutes),
            calibration: RwLock::new(CalibrationData::default()),
            battery: RwLock::new(85),
            rssi: AtomicI16::new(-50),
            read_count: AtomicU32::new(0),
            should_fail: AtomicBool::new(false),
            fail_message: RwLock::new("Mock failure".to_string()),
            read_latency_ms: AtomicU64::new(0),
            connect_latency_ms: AtomicU64::new(0),
            fail_count: AtomicU32::new(0),
            remaining_failures: AtomicU32::new(0),
        }
    }

    fn default_reading() -> CurrentReading {
        CurrentReading {
            co2: 800,
            temperature: 22.5,
            pressure: 1013.2,
            humidity: 50,
            battery: 85,
            status: Status::Green,
            interval: 300,
            age: 60,
            captured_at: None,
            radon: None,
            radiation_rate: None,
            radiation_total: None,
        }
    }

    fn default_info(name: &str) -> DeviceInfo {
        DeviceInfo {
            name: name.to_string(),
            model: "Aranet4".to_string(),
            serial: "MOCK-12345".to_string(),
            firmware: "v1.5.0".to_string(),
            hardware: "1.0".to_string(),
            software: "1.5.0".to_string(),
            manufacturer: "SAF Tehnika".to_string(),
        }
    }

    /// Connect to the mock device.
    pub async fn connect(&self) -> Result<()> {
        use crate::error::DeviceNotFoundReason;

        // Simulate connect latency
        let latency = self.connect_latency_ms.load(Ordering::Relaxed);
        if latency > 0 {
            tokio::time::sleep(Duration::from_millis(latency)).await;
        }

        // Check for transient failures first
        if self.remaining_failures.load(Ordering::Relaxed) > 0 {
            self.remaining_failures.fetch_sub(1, Ordering::Relaxed);
            return Err(Error::DeviceNotFound(DeviceNotFoundReason::NotFound {
                identifier: self.name.clone(),
            }));
        }

        if self.should_fail.load(Ordering::Relaxed) {
            return Err(Error::DeviceNotFound(DeviceNotFoundReason::NotFound {
                identifier: self.name.clone(),
            }));
        }
        self.connected.store(true, Ordering::Relaxed);
        Ok(())
    }

    /// Disconnect from the mock device.
    pub async fn disconnect(&self) -> Result<()> {
        self.connected.store(false, Ordering::Relaxed);
        Ok(())
    }

    /// Check if connected (sync method for internal use).
    pub fn is_connected_sync(&self) -> bool {
        self.connected.load(Ordering::Relaxed)
    }

    /// Get the device name.
    pub fn name(&self) -> &str {
        &self.name
    }

    /// Get the device address.
    pub fn address(&self) -> &str {
        &self.address
    }

    /// Get the device type.
    pub fn device_type(&self) -> DeviceType {
        self.device_type
    }

    /// Read current sensor values.
    pub async fn read_current(&self) -> Result<CurrentReading> {
        self.check_connected()?;
        self.check_should_fail().await?;

        self.read_count.fetch_add(1, Ordering::Relaxed);
        Ok(*self.current_reading.read().await)
    }

    /// Read battery level.
    pub async fn read_battery(&self) -> Result<u8> {
        self.check_connected()?;
        self.check_should_fail().await?;
        Ok(*self.battery.read().await)
    }

    /// Read RSSI (signal strength).
    pub async fn read_rssi(&self) -> Result<i16> {
        self.check_connected()?;
        self.check_should_fail().await?;
        Ok(self.rssi.load(Ordering::Relaxed))
    }

    /// Read device info.
    pub async fn read_device_info(&self) -> Result<DeviceInfo> {
        self.check_connected()?;
        self.check_should_fail().await?;
        Ok(self.device_info.read().await.clone())
    }

    /// Get history info.
    pub async fn get_history_info(&self) -> Result<HistoryInfo> {
        self.check_connected()?;
        self.check_should_fail().await?;

        let history = self.history.read().await;
        let interval = self.interval.read().await;

        Ok(HistoryInfo {
            total_readings: history.len() as u16,
            interval_seconds: interval.as_seconds(),
            seconds_since_update: 60,
        })
    }

    /// Download history.
    pub async fn download_history(&self) -> Result<Vec<HistoryRecord>> {
        self.check_connected()?;
        self.check_should_fail().await?;
        Ok(self.history.read().await.clone())
    }

    /// Download history with options.
    pub async fn download_history_with_options(
        &self,
        options: HistoryOptions,
    ) -> Result<Vec<HistoryRecord>> {
        self.check_connected()?;
        self.check_should_fail().await?;

        let history = self.history.read().await;
        let start = options.start_index.unwrap_or(0) as usize;
        let end = options
            .end_index
            .map(|e| e as usize)
            .unwrap_or(history.len());

        // Report progress if callback provided
        if let Some(ref _callback) = options.progress_callback {
            // For mock, we report progress immediately
            let progress = crate::history::HistoryProgress::new(
                crate::history::HistoryParam::Co2,
                1,
                1,
                history.len().min(end).saturating_sub(start),
            );
            options.report_progress(&progress);
        }

        Ok(history
            .iter()
            .skip(start)
            .take(end.saturating_sub(start))
            .cloned()
            .collect())
    }

    /// Get the measurement interval.
    pub async fn get_interval(&self) -> Result<MeasurementInterval> {
        self.check_connected()?;
        self.check_should_fail().await?;
        Ok(*self.interval.read().await)
    }

    /// Set the measurement interval.
    pub async fn set_interval(&self, interval: MeasurementInterval) -> Result<()> {
        self.check_connected()?;
        self.check_should_fail().await?;
        *self.interval.write().await = interval;
        Ok(())
    }

    /// Get calibration data.
    pub async fn get_calibration(&self) -> Result<CalibrationData> {
        self.check_connected()?;
        self.check_should_fail().await?;
        Ok(self.calibration.read().await.clone())
    }

    fn check_connected(&self) -> Result<()> {
        if !self.connected.load(Ordering::Relaxed) {
            Err(Error::NotConnected)
        } else {
            Ok(())
        }
    }

    async fn check_should_fail(&self) -> Result<()> {
        // Simulate read latency
        let latency = self.read_latency_ms.load(Ordering::Relaxed);
        if latency > 0 {
            tokio::time::sleep(Duration::from_millis(latency)).await;
        }

        // Check for transient failures first
        if self.remaining_failures.load(Ordering::Relaxed) > 0 {
            self.remaining_failures.fetch_sub(1, Ordering::Relaxed);
            return Err(Error::InvalidData(self.fail_message.read().await.clone()));
        }

        if self.should_fail.load(Ordering::Relaxed) {
            Err(Error::InvalidData(self.fail_message.read().await.clone()))
        } else {
            Ok(())
        }
    }

    // --- Test control methods ---

    /// Set the current reading for testing.
    pub async fn set_reading(&self, reading: CurrentReading) {
        *self.current_reading.write().await = reading;
    }

    /// Set CO2 level directly.
    pub async fn set_co2(&self, co2: u16) {
        self.current_reading.write().await.co2 = co2;
    }

    /// Set temperature directly.
    pub async fn set_temperature(&self, temp: f32) {
        self.current_reading.write().await.temperature = temp;
    }

    /// Set battery level.
    pub async fn set_battery(&self, level: u8) {
        *self.battery.write().await = level;
        self.current_reading.write().await.battery = level;
    }

    /// Set RSSI (signal strength) for testing.
    pub fn set_rssi(&self, rssi: i16) {
        self.rssi.store(rssi, Ordering::Relaxed);
    }

    /// Add history records.
    pub async fn add_history(&self, records: Vec<HistoryRecord>) {
        self.history.write().await.extend(records);
    }

    /// Make the device fail on next operation.
    pub async fn set_should_fail(&self, fail: bool, message: Option<&str>) {
        self.should_fail.store(fail, Ordering::Relaxed);
        if let Some(msg) = message {
            *self.fail_message.write().await = msg.to_string();
        }
    }

    /// Get the number of read operations performed.
    pub fn read_count(&self) -> u32 {
        self.read_count.load(Ordering::Relaxed)
    }

    /// Reset read count.
    pub fn reset_read_count(&self) {
        self.read_count.store(0, Ordering::Relaxed);
    }

    /// Set simulated read latency.
    ///
    /// Each read operation will be delayed by this duration.
    /// Set to `Duration::ZERO` to disable latency simulation.
    pub fn set_read_latency(&self, latency: Duration) {
        self.read_latency_ms
            .store(latency.as_millis() as u64, Ordering::Relaxed);
    }

    /// Set simulated connect latency.
    ///
    /// Connect operations will be delayed by this duration.
    /// Set to `Duration::ZERO` to disable latency simulation.
    pub fn set_connect_latency(&self, latency: Duration) {
        self.connect_latency_ms
            .store(latency.as_millis() as u64, Ordering::Relaxed);
    }

    /// 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 set_transient_failures(&self, count: u32) {
        self.fail_count.store(count, Ordering::Relaxed);
        self.remaining_failures.store(count, Ordering::Relaxed);
    }

    /// Reset transient failure counter.
    pub fn reset_transient_failures(&self) {
        self.remaining_failures
            .store(self.fail_count.load(Ordering::Relaxed), Ordering::Relaxed);
    }

    /// Get the number of remaining transient failures.
    pub fn remaining_failures(&self) -> u32 {
        self.remaining_failures.load(Ordering::Relaxed)
    }
}

// Implement the AranetDevice trait for MockDevice
#[async_trait]
impl AranetDevice for MockDevice {
    // --- Connection Management ---

    async fn is_connected(&self) -> bool {
        self.is_connected_sync()
    }

    async fn disconnect(&self) -> Result<()> {
        MockDevice::disconnect(self).await
    }

    // --- Device Identity ---

    fn name(&self) -> Option<&str> {
        Some(MockDevice::name(self))
    }

    fn address(&self) -> &str {
        MockDevice::address(self)
    }

    fn device_type(&self) -> Option<DeviceType> {
        Some(MockDevice::device_type(self))
    }

    // --- Current Readings ---

    async fn read_current(&self) -> Result<CurrentReading> {
        MockDevice::read_current(self).await
    }

    async fn read_device_info(&self) -> Result<DeviceInfo> {
        MockDevice::read_device_info(self).await
    }

    async fn read_rssi(&self) -> Result<i16> {
        MockDevice::read_rssi(self).await
    }

    // --- Battery ---

    async fn read_battery(&self) -> Result<u8> {
        MockDevice::read_battery(self).await
    }

    // --- History ---

    async fn get_history_info(&self) -> Result<crate::history::HistoryInfo> {
        MockDevice::get_history_info(self).await
    }

    async fn download_history(&self) -> Result<Vec<HistoryRecord>> {
        MockDevice::download_history(self).await
    }

    async fn download_history_with_options(
        &self,
        options: HistoryOptions,
    ) -> Result<Vec<HistoryRecord>> {
        MockDevice::download_history_with_options(self, options).await
    }

    // --- Settings ---

    async fn get_interval(&self) -> Result<MeasurementInterval> {
        MockDevice::get_interval(self).await
    }

    async fn set_interval(&self, interval: MeasurementInterval) -> Result<()> {
        MockDevice::set_interval(self, interval).await
    }

    async fn get_calibration(&self) -> Result<CalibrationData> {
        MockDevice::get_calibration(self).await
    }
}

/// Builder for creating mock devices with custom settings.
#[derive(Debug)]
pub struct MockDeviceBuilder {
    name: String,
    device_type: DeviceType,
    co2: u16,
    temperature: f32,
    pressure: f32,
    humidity: u8,
    battery: u8,
    status: Status,
    auto_connect: bool,
}

impl Default for MockDeviceBuilder {
    fn default() -> Self {
        Self {
            name: "Mock Aranet4".to_string(),
            device_type: DeviceType::Aranet4,
            co2: 800,
            temperature: 22.5,
            pressure: 1013.2,
            humidity: 50,
            battery: 85,
            status: Status::Green,
            auto_connect: true,
        }
    }
}

impl MockDeviceBuilder {
    /// Create a new builder.
    #[must_use]
    pub fn new() -> Self {
        Self::default()
    }

    /// Set the device name.
    #[must_use]
    pub fn name(mut self, name: &str) -> Self {
        self.name = name.to_string();
        self
    }

    /// Set the device type.
    #[must_use]
    pub fn device_type(mut self, device_type: DeviceType) -> Self {
        self.device_type = device_type;
        self
    }

    /// Set the CO2 level.
    #[must_use]
    pub fn co2(mut self, co2: u16) -> Self {
        self.co2 = co2;
        self
    }

    /// Set the temperature.
    #[must_use]
    pub fn temperature(mut self, temp: f32) -> Self {
        self.temperature = temp;
        self
    }

    /// Set the pressure.
    #[must_use]
    pub fn pressure(mut self, pressure: f32) -> Self {
        self.pressure = pressure;
        self
    }

    /// Set the humidity.
    #[must_use]
    pub fn humidity(mut self, humidity: u8) -> Self {
        self.humidity = humidity;
        self
    }

    /// Set the battery level.
    #[must_use]
    pub fn battery(mut self, battery: u8) -> Self {
        self.battery = battery;
        self
    }

    /// Set the status.
    #[must_use]
    pub fn status(mut self, status: Status) -> Self {
        self.status = status;
        self
    }

    /// Set whether to auto-connect.
    #[must_use]
    pub fn auto_connect(mut self, auto: bool) -> Self {
        self.auto_connect = auto;
        self
    }

    /// Build the mock device.
    ///
    /// Note: This is a sync method that sets initial state directly.
    /// The device is created with the specified reading already set.
    #[must_use]
    pub fn build(self) -> MockDevice {
        let reading = CurrentReading {
            co2: self.co2,
            temperature: self.temperature,
            pressure: self.pressure,
            humidity: self.humidity,
            battery: self.battery,
            status: self.status,
            interval: 300,
            age: 60,
            captured_at: None,
            radon: None,
            radiation_rate: None,
            radiation_total: None,
        };

        MockDevice {
            name: self.name.clone(),
            address: format!("MOCK-{:06X}", rand::random::<u32>() % 0xFFFFFF),
            device_type: self.device_type,
            connected: AtomicBool::new(self.auto_connect),
            current_reading: RwLock::new(reading),
            device_info: RwLock::new(MockDevice::default_info(&self.name)),
            history: RwLock::new(Vec::new()),
            interval: RwLock::new(MeasurementInterval::FiveMinutes),
            calibration: RwLock::new(CalibrationData::default()),
            battery: RwLock::new(self.battery),
            rssi: AtomicI16::new(-50),
            read_count: AtomicU32::new(0),
            should_fail: AtomicBool::new(false),
            fail_message: RwLock::new("Mock failure".to_string()),
            read_latency_ms: AtomicU64::new(0),
            connect_latency_ms: AtomicU64::new(0),
            fail_count: AtomicU32::new(0),
            remaining_failures: AtomicU32::new(0),
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::traits::AranetDevice;

    #[tokio::test]
    async fn test_mock_device_connect() {
        let device = MockDevice::new("Test", DeviceType::Aranet4);
        assert!(!device.is_connected_sync());

        device.connect().await.unwrap();
        assert!(device.is_connected_sync());

        device.disconnect().await.unwrap();
        assert!(!device.is_connected_sync());
    }

    #[tokio::test]
    async fn test_mock_device_read() {
        let device = MockDeviceBuilder::new().co2(1200).temperature(25.0).build();

        let reading = device.read_current().await.unwrap();
        assert_eq!(reading.co2, 1200);
        assert!((reading.temperature - 25.0).abs() < 0.01);
    }

    #[tokio::test]
    async fn test_mock_device_fail() {
        let device = MockDeviceBuilder::new().build();
        device.set_should_fail(true, Some("Test error")).await;

        let result = device.read_current().await;
        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("Test error"));
    }

    #[tokio::test]
    async fn test_mock_device_not_connected() {
        let device = MockDeviceBuilder::new().auto_connect(false).build();

        let result = device.read_current().await;
        assert!(matches!(result, Err(Error::NotConnected)));
    }

    #[test]
    fn test_builder_defaults() {
        let device = MockDeviceBuilder::new().build();
        assert!(device.is_connected_sync());
        assert_eq!(device.device_type(), DeviceType::Aranet4);
    }

    #[tokio::test]
    async fn test_aranet_device_trait() {
        let device = MockDeviceBuilder::new().co2(1000).build();

        // Use via trait
        async fn check_via_trait<D: AranetDevice>(d: &D) -> u16 {
            d.read_current().await.unwrap().co2
        }

        assert_eq!(check_via_trait(&device).await, 1000);
    }
}