mock_installer/
lib.rs

1// Copyright 2020 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use assert_matches::assert_matches;
6use fidl_fuchsia_update_installer::{
7    InstallerMarker, InstallerProxy, InstallerRequest, InstallerRequestStream, MonitorProxy,
8    Options, RebootControllerRequest, UpdateNotStartedReason,
9};
10use fidl_fuchsia_update_installer_ext::{State, StateId};
11use fuchsia_async as fasync;
12use fuchsia_sync::Mutex;
13use futures::channel::mpsc;
14use futures::prelude::*;
15use pretty_assertions::assert_eq;
16use std::sync::Arc;
17
18#[derive(PartialEq, Debug)]
19pub enum CapturedUpdateInstallerRequest {
20    StartUpdate { url: String, options: Options, reboot_controller_present: bool },
21    SuspendUpdate { attempt_id: Option<String> },
22    ResumeUpdate { attempt_id: Option<String> },
23    CancelUpdate { attempt_id: Option<String> },
24}
25
26// Options does not impl Eq, but it is semantically Eq.
27impl Eq for CapturedUpdateInstallerRequest {}
28
29#[derive(Eq, PartialEq, Debug)]
30pub enum CapturedRebootControllerRequest {
31    Unblock,
32    Detach,
33}
34
35pub struct MockUpdateInstallerServiceBuilder {
36    states: Vec<State>,
37    states_receiver: Option<mpsc::Receiver<State>>,
38    start_update_response: Result<String, UpdateNotStartedReason>,
39}
40
41impl MockUpdateInstallerServiceBuilder {
42    /// The mock installer will sends these states to the caller of StartUpdate.
43    /// It will only work for the first StartUpdate call.
44    /// Ignored if states_receiver exists.
45    pub fn states(self, states: Vec<State>) -> Self {
46        Self { states, ..self }
47    }
48
49    /// When the mock installer receives a state it will forward it to the caller of StartUpdate.
50    /// It will only work for the first StartUpdate call.
51    pub fn states_receiver(self, states_receiver: mpsc::Receiver<State>) -> Self {
52        Self { states_receiver: Some(states_receiver), ..self }
53    }
54
55    pub fn start_update_response(
56        self,
57        start_update_response: Result<String, UpdateNotStartedReason>,
58    ) -> Self {
59        Self { start_update_response, ..self }
60    }
61
62    pub fn build(self) -> MockUpdateInstallerService {
63        let Self { states, states_receiver, start_update_response } = self;
64        let states_receiver = match states_receiver {
65            Some(states_receiver) => states_receiver,
66            None => {
67                let (mut sender, receiver) = mpsc::channel(0);
68                fasync::Task::spawn(async move {
69                    for state in states {
70                        sender.send(state).await.unwrap();
71                    }
72                })
73                .detach();
74                receiver
75            }
76        };
77        MockUpdateInstallerService {
78            start_update_response: Mutex::new(start_update_response),
79            states_receiver: Mutex::new(Some(states_receiver)),
80            captured_args: Mutex::new(vec![]),
81            reboot_controller_requests: Mutex::new(vec![]),
82        }
83    }
84}
85
86pub struct MockUpdateInstallerService {
87    start_update_response: Mutex<Result<String, UpdateNotStartedReason>>,
88    states_receiver: Mutex<Option<mpsc::Receiver<State>>>,
89    captured_args: Mutex<Vec<CapturedUpdateInstallerRequest>>,
90    reboot_controller_requests: Mutex<Vec<CapturedRebootControllerRequest>>,
91}
92
93impl MockUpdateInstallerService {
94    pub fn builder() -> MockUpdateInstallerServiceBuilder {
95        MockUpdateInstallerServiceBuilder {
96            states: vec![],
97            start_update_response: Ok("id".into()),
98            states_receiver: None,
99        }
100    }
101
102    pub fn with_states(states: Vec<State>) -> Self {
103        Self::builder().states(states).build()
104    }
105
106    pub fn with_response(start_update_response: Result<String, UpdateNotStartedReason>) -> Self {
107        Self::builder().start_update_response(start_update_response).build()
108    }
109
110    pub async fn run_service(self: Arc<Self>, mut stream: InstallerRequestStream) {
111        while let Some(req) = stream.try_next().await.unwrap() {
112            match req {
113                InstallerRequest::StartUpdate {
114                    url,
115                    options,
116                    monitor,
117                    reboot_controller,
118                    signature: _,
119                    responder,
120                } => {
121                    self.captured_args.lock().push(CapturedUpdateInstallerRequest::StartUpdate {
122                        url: url.url,
123                        options,
124                        reboot_controller_present: reboot_controller.is_some(),
125                    });
126                    let proxy =
127                        MonitorProxy::new(fasync::Channel::from_channel(monitor.into_channel()));
128                    fasync::Task::spawn(Arc::clone(&self).send_states(proxy)).detach();
129                    if let Some(reboot_controller) = reboot_controller {
130                        let service = Arc::clone(&self);
131                        fasync::Task::spawn(async move {
132                            let mut stream = reboot_controller.into_stream();
133
134                            while let Some(request) = stream.try_next().await.unwrap() {
135                                let request = match request {
136                                    RebootControllerRequest::Unblock { .. } => {
137                                        CapturedRebootControllerRequest::Unblock
138                                    }
139                                    RebootControllerRequest::Detach { .. } => {
140                                        CapturedRebootControllerRequest::Detach
141                                    }
142                                };
143                                service.reboot_controller_requests.lock().push(request);
144                            }
145                        })
146                        .detach();
147                    }
148                    let response = self.start_update_response.lock();
149                    responder.send(response.as_deref().map_err(|e| *e)).unwrap();
150                }
151                InstallerRequest::SuspendUpdate { attempt_id, responder } => {
152                    self.captured_args
153                        .lock()
154                        .push(CapturedUpdateInstallerRequest::SuspendUpdate { attempt_id });
155                    responder.send(Ok(())).unwrap();
156                }
157                InstallerRequest::ResumeUpdate { attempt_id, responder } => {
158                    self.captured_args
159                        .lock()
160                        .push(CapturedUpdateInstallerRequest::ResumeUpdate { attempt_id });
161                    responder.send(Ok(())).unwrap();
162                }
163                InstallerRequest::CancelUpdate { attempt_id, responder } => {
164                    self.captured_args
165                        .lock()
166                        .push(CapturedUpdateInstallerRequest::CancelUpdate { attempt_id });
167                    responder.send(Ok(())).unwrap();
168                }
169                InstallerRequest::MonitorUpdate { .. } => {
170                    panic!("unexpected request: {req:?}");
171                }
172            }
173        }
174    }
175
176    async fn send_states(self: Arc<Self>, monitor: MonitorProxy) {
177        let mut receiver = self
178            .states_receiver
179            .lock()
180            .take()
181            .expect("mock installer only supports a single StartUpdate call");
182
183        while let Some(state) = receiver.next().await {
184            Self::send_state(state, &monitor).await;
185        }
186    }
187
188    async fn send_state(state: State, monitor: &MonitorProxy) {
189        let is_reboot = state.id() == StateId::Reboot;
190        let result = monitor.on_state(&state.into()).await;
191        if is_reboot {
192            assert_matches!(result, Err(_));
193        } else {
194            assert_matches!(result, Ok(()));
195        }
196    }
197
198    pub fn assert_installer_called_with(&self, expected_args: Vec<CapturedUpdateInstallerRequest>) {
199        assert_eq!(*self.captured_args.lock(), expected_args);
200    }
201
202    pub fn assert_reboot_controller_called_with(
203        &self,
204        expected_requests: Vec<CapturedRebootControllerRequest>,
205    ) {
206        assert_eq!(*self.reboot_controller_requests.lock(), expected_requests);
207    }
208
209    pub fn spawn_installer_service(self: Arc<Self>) -> InstallerProxy {
210        let (proxy, stream) = fidl::endpoints::create_proxy_and_stream::<InstallerMarker>();
211
212        fasync::Task::spawn(self.run_service(stream)).detach();
213
214        proxy
215    }
216}
217
218#[cfg(test)]
219mod tests {
220    use super::*;
221    use fidl_fuchsia_update_installer::{Initiator, MonitorMarker, MonitorRequest};
222    use pretty_assertions::assert_eq;
223
224    #[fasync::run_singlethreaded(test)]
225    async fn test_mock_installer() {
226        let installer_service =
227            Arc::new(MockUpdateInstallerService::with_states(vec![State::Prepare]));
228        let proxy = Arc::clone(&installer_service).spawn_installer_service();
229        let url =
230            fidl_fuchsia_pkg::PackageUrl { url: "fuchsia-pkg://fuchsia.com/update".to_string() };
231        let options = Options {
232            initiator: Some(Initiator::User),
233            should_write_recovery: Some(true),
234            allow_attach_to_existing_attempt: Some(true),
235            ..Default::default()
236        };
237        let (monitor_client_end, stream) =
238            fidl::endpoints::create_request_stream::<MonitorMarker>();
239        proxy
240            .start_update(&url, &options, monitor_client_end, None, None)
241            .await
242            .expect("made start_update call")
243            .expect("start_update call succeeded");
244        assert_eq!(
245            vec![State::Prepare],
246            stream
247                .map_ok(|MonitorRequest::OnState { state, responder }| {
248                    responder.send().unwrap();
249                    State::try_from(state).unwrap()
250                })
251                .try_collect::<Vec<_>>()
252                .await
253                .unwrap()
254        );
255    }
256}
mock_installer/lib.rs

mock_installer/
lib.rs
