1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use super::TestDeviceImplCreator;
use crate::{
  core::errors::ButtplugError,
  server::comm_managers::{
    DeviceCommunicationEvent,
    DeviceCommunicationManager,
    DeviceCommunicationManagerCreator,
  },
};
use async_std::sync::{Arc, Mutex, Sender};
use async_trait::async_trait;

pub struct TestDeviceCommunicationManager {
  device_sender: Sender<DeviceCommunicationEvent>,
  devices: Arc<Mutex<Vec<Box<TestDeviceImplCreator>>>>,
}

impl TestDeviceCommunicationManager {
  pub fn get_devices_clone(&self) -> Arc<Mutex<Vec<Box<TestDeviceImplCreator>>>> {
    self.devices.clone()
  }
}

impl DeviceCommunicationManagerCreator for TestDeviceCommunicationManager {
  fn new(device_sender: Sender<DeviceCommunicationEvent>) -> Self {
    Self {
      device_sender,
      devices: Arc::new(Mutex::new(vec![])),
    }
  }
}

#[async_trait]
impl DeviceCommunicationManager for TestDeviceCommunicationManager {
  async fn start_scanning(&mut self) -> Result<(), ButtplugError> {
    let mut devices = self.devices.lock().await;
    if devices.is_empty() {
      panic!("No devices for test device comm manager to emit!");
    }
    while let Some(d) = devices.pop() {
      self
        .device_sender
        .send(DeviceCommunicationEvent::DeviceFound(d))
        .await;
    }
    Ok(())
  }

  async fn stop_scanning(&mut self) -> Result<(), ButtplugError> {
    Ok(())
  }

  fn is_scanning(&mut self) -> bool {
    false
  }
}

#[cfg(test)]
mod test {
  #[cfg(test)]
  mod test {
    use crate::{
      core::messages::{self, ButtplugMessageSpecVersion, ButtplugOutMessage},
      device::device::DeviceImpl,
      server::ButtplugServer,
      test::TestDevice,
    };
    use async_std::{prelude::StreamExt, task};

    #[test]
    fn test_test_device_comm_manager() {
      let _ = env_logger::builder().is_test(true).try_init();
      let (mut server, mut recv) = ButtplugServer::new("Test Server", 0);
      let (mut device, device_creator) =
        TestDevice::new_bluetoothle_test_device_impl_creator("Massage Demo");

      task::block_on(async {
        let devices = server.add_test_comm_manager();
        devices.lock().await.push(Box::new(device_creator));
        let msg =
          messages::RequestServerInfo::new("Test Client", ButtplugMessageSpecVersion::Version2);
        let mut reply = server.parse_message(&msg.into()).await;
        assert!(reply.is_ok(), format!("Should get back ok: {:?}", reply));
        reply = server
          .parse_message(&messages::StartScanning::default().into())
          .await;
        assert!(reply.is_ok(), format!("Should get back ok: {:?}", reply));
        // Check that we got an event back about a new device.
        let msg = recv.next().await.unwrap();
        if let ButtplugOutMessage::DeviceAdded(da) = msg {
          assert_eq!(da.device_name, "Aneros Vivi");
        } else {
          assert!(
            false,
            format!(
              "Returned message was not a DeviceAdded message or timed out: {:?}",
              msg
            )
          );
        }
        device.disconnect().await;
        // Check that we got an event back about a removed device.
        let msg = recv.next().await.unwrap();
        if let ButtplugOutMessage::DeviceRemoved(da) = msg {
          assert_eq!(da.device_index, 0);
        } else {
          assert!(
            false,
            format!(
              "Returned message was not a DeviceRemoved message or timed out: {:?}",
              msg
            )
          );
        }
      });
    }
  }
}