| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use account_common::{AccountManagerError, FidlLocalAccountId, LocalAccountId, ResultExt}; |
| use anyhow::{format_err, Error}; |
| use fidl::endpoints::{create_endpoints, ClientEnd, ServerEnd}; |
| use fidl_fuchsia_auth::{AppConfig, AuthenticationContextProviderMarker, Status as AuthStatus}; |
| use fidl_fuchsia_auth::{AuthProviderConfig, UserProfileInfo}; |
| use fidl_fuchsia_identity_account::{ |
| AccountAuthState, AccountListenerMarker, AccountListenerOptions, AccountManagerRequest, |
| AccountManagerRequestStream, AccountMarker, Error as ApiError, Lifetime, Scenario, |
| }; |
| use fuchsia_component::fuchsia_single_component_package_url; |
| use fuchsia_inspect::{Inspector, Property}; |
| use futures::lock::Mutex; |
| use futures::prelude::*; |
| use lazy_static::lazy_static; |
| use log::{info, warn}; |
| use std::path::PathBuf; |
| use std::sync::Arc; |
| |
| use crate::account_event_emitter::{AccountEvent, AccountEventEmitter}; |
| use crate::account_handler_connection::AccountHandlerConnection; |
| use crate::account_handler_context::AccountHandlerContext; |
| use crate::account_map::AccountMap; |
| use crate::inspect; |
| |
| const SELF_URL: &str = fuchsia_single_component_package_url!("account_manager"); |
| |
| lazy_static! { |
| |
| /// The Auth scopes used for authorization during service provider-based account provisioning. |
| /// An empty vector means that the auth provider should use its default scopes. |
| static ref APP_SCOPES: Vec<String> = Vec::default(); |
| } |
| |
| /// The core component of the account system for Fuchsia. |
| /// |
| /// The AccountManager maintains the set of Fuchsia accounts that are provisioned on the device, |
| /// launches and configures AuthenticationProvider components to perform authentication via |
| /// service providers, and launches and delegates to AccountHandler component instances to |
| /// determine the detailed state and authentication for each account. |
| /// |
| /// `AHC` An AccountHandlerConnection used to spawn new AccountHandler components. |
| pub struct AccountManager<AHC: AccountHandlerConnection> { |
| /// The account map maintains the state of all accounts as well as connections to their account |
| /// handlers. |
| account_map: Mutex<AccountMap<AHC>>, |
| |
| /// Contains the client ends of all AccountListeners which are subscribed to account events. |
| event_emitter: AccountEventEmitter, |
| |
| /// Helper for outputting auth_provider information via fuchsia_inspect. Must be retained |
| /// to avoid dropping the static properties it contains. |
| _auth_providers_inspect: inspect::AuthProviders, |
| } |
| |
| impl<AHC: AccountHandlerConnection> AccountManager<AHC> { |
| /// Constructs a new AccountManager, loading existing set of accounts from `data_dir`, and an |
| /// auth provider configuration. The directory must exist at construction. |
| pub fn new( |
| data_dir: PathBuf, |
| auth_provider_config: &[AuthProviderConfig], |
| auth_mechanism_ids: &[String], |
| inspector: &Inspector, |
| ) -> Result<AccountManager<AHC>, Error> { |
| let context = |
| Arc::new(AccountHandlerContext::new(auth_provider_config, auth_mechanism_ids)); |
| let account_map = AccountMap::load(data_dir, Arc::clone(&context), inspector.root())?; |
| |
| // Initialize the structs used to output state through the inspect system. |
| let auth_providers_inspect = inspect::AuthProviders::new(inspector.root()); |
| let auth_provider_types: Vec<String> = |
| auth_provider_config.iter().map(|apc| apc.auth_provider_type.clone()).collect(); |
| auth_providers_inspect.types.set(&auth_provider_types.join(",")); |
| let event_emitter = AccountEventEmitter::new(inspector.root()); |
| |
| Ok(Self { |
| account_map: Mutex::new(account_map), |
| event_emitter, |
| _auth_providers_inspect: auth_providers_inspect, |
| }) |
| } |
| |
| /// Asynchronously handles the supplied stream of `AccountManagerRequest` messages. |
| pub async fn handle_requests_from_stream( |
| &self, |
| mut stream: AccountManagerRequestStream, |
| ) -> Result<(), Error> { |
| while let Some(req) = stream.try_next().await? { |
| self.handle_request(req).await?; |
| } |
| Ok(()) |
| } |
| |
| /// Handles a single request to the AccountManager. |
| pub async fn handle_request(&self, req: AccountManagerRequest) -> Result<(), fidl::Error> { |
| match req { |
| AccountManagerRequest::GetAccountIds { responder } => { |
| let response = self.get_account_ids().await; |
| responder.send(&response)?; |
| } |
| AccountManagerRequest::GetAccountAuthStates { scenario, responder } => { |
| let mut response = self.get_account_auth_states(scenario).await; |
| responder.send(&mut response)?; |
| } |
| AccountManagerRequest::GetAccount { id, context_provider, account, responder } => { |
| let mut response = self.get_account(id.into(), context_provider, account).await; |
| responder.send(&mut response)?; |
| } |
| AccountManagerRequest::RegisterAccountListener { listener, options, responder } => { |
| let mut response = self.register_account_listener(listener, options).await; |
| responder.send(&mut response)?; |
| } |
| AccountManagerRequest::RemoveAccount { id, force, responder } => { |
| let mut response = self.remove_account(id.into(), force).await; |
| responder.send(&mut response)?; |
| } |
| AccountManagerRequest::ProvisionFromAuthProvider { |
| auth_context_provider, |
| auth_provider_type, |
| lifetime, |
| auth_mechanism_id, |
| responder, |
| } => { |
| let mut response = self |
| .provision_from_auth_provider( |
| auth_context_provider, |
| auth_provider_type, |
| lifetime, |
| auth_mechanism_id, |
| ) |
| .await; |
| responder.send(&mut response)?; |
| } |
| AccountManagerRequest::ProvisionNewAccount { |
| lifetime, |
| auth_mechanism_id, |
| responder, |
| } => { |
| let mut response = self.provision_new_account(lifetime, auth_mechanism_id).await; |
| responder.send(&mut response)?; |
| } |
| AccountManagerRequest::GetAuthenticationMechanisms { responder } => { |
| responder.send(&mut Err(ApiError::UnsupportedOperation))?; |
| } |
| } |
| Ok(()) |
| } |
| |
| async fn get_account_ids(&self) -> Vec<FidlLocalAccountId> { |
| self.account_map.lock().await.get_account_ids().iter().map(|id| id.clone().into()).collect() |
| } |
| |
| async fn get_account_auth_states( |
| &self, |
| _scenario: Scenario, |
| ) -> Result<Vec<AccountAuthState>, ApiError> { |
| // TODO(jsankey): Collect authentication state from AccountHandler instances rather than |
| // returning a fixed value. This will involve opening account handler connections (in |
| // parallel) for all of the accounts where encryption keys for the account's data partition |
| // are available. |
| return Err(ApiError::UnsupportedOperation); |
| } |
| |
| async fn get_account( |
| &self, |
| id: LocalAccountId, |
| auth_context_provider: ClientEnd<AuthenticationContextProviderMarker>, |
| account: ServerEnd<AccountMarker>, |
| ) -> Result<(), ApiError> { |
| let mut account_map = self.account_map.lock().await; |
| let account_handler = account_map.get_handler(&id).await.map_err(|err| { |
| warn!("Failure getting account handler connection: {:?}", err); |
| err.api_error |
| })?; |
| account_handler.proxy().unlock_account().await.map_err(|_| ApiError::Resource)??; |
| |
| account_handler.proxy().get_account(auth_context_provider, account).await.map_err( |
| |err| { |
| warn!("Failure calling get account: {:?}", err); |
| ApiError::Resource |
| }, |
| )? |
| } |
| |
| async fn register_account_listener( |
| &self, |
| listener: ClientEnd<AccountListenerMarker>, |
| options: AccountListenerOptions, |
| ) -> Result<(), ApiError> { |
| match (&options.scenario, &options.granularity) { |
| (None, Some(_)) => return Err(ApiError::InvalidRequest), |
| (Some(_), _) => return Err(ApiError::UnsupportedOperation), |
| (None, None) => {} |
| }; |
| let account_ids = self.account_map.lock().await.get_account_ids(); |
| let proxy = listener.into_proxy().map_err(|err| { |
| warn!("Could not convert AccountListener client end to proxy {:?}", err); |
| ApiError::InvalidRequest |
| })?; |
| self.event_emitter.add_listener(proxy, options, &account_ids).await.map_err(|err| { |
| warn!("Could not instantiate AccountListener client {:?}", err); |
| ApiError::Unknown |
| })?; |
| info!("AccountListener established"); |
| Ok(()) |
| } |
| |
| async fn remove_account( |
| &self, |
| account_id: LocalAccountId, |
| force: bool, |
| ) -> Result<(), ApiError> { |
| let mut account_map = self.account_map.lock().await; |
| let account_handler = account_map.get_handler(&account_id).await.map_err(|err| { |
| warn!("Could not get account handler for account removal {:?}", err); |
| err.api_error |
| })?; |
| // TODO(fxbug.dev/43491): Make a conscious decision on what should happen when removing |
| // a locked account. |
| account_handler.proxy().unlock_account().await.map_err(|_| ApiError::Resource)??; |
| account_handler.proxy().remove_account(force).await.map_err(|_| ApiError::Resource)??; |
| account_handler.terminate().await; |
| // Emphemeral accounts were never included in the StoredAccountList and so it does not need |
| // to be modified when they are removed. |
| // TODO(fxbug.dev/39455): Handle irrecoverable, corrupt state. |
| account_map.remove_account(&account_id).await.map_err(|err| { |
| warn!("Could not remove account: {:?}", err); |
| // TODO(fxbug.dev/39829): Improve error mapping. |
| if err.api_error == ApiError::NotFound { |
| // We already checked for existence, so NotFound is unexpected |
| ApiError::Internal |
| } else { |
| err.api_error |
| } |
| })?; |
| let event = AccountEvent::AccountRemoved(account_id.clone()); |
| self.event_emitter.publish(&event).await; |
| Ok(()) |
| } |
| |
| /// Creates a new account handler connection, then creates an account within it, |
| /// and finally returns the connection. |
| async fn create_account_internal( |
| &self, |
| lifetime: Lifetime, |
| auth_mechanism_id: Option<String>, |
| ) -> Result<Arc<AHC>, ApiError> { |
| let account_handler = |
| self.account_map.lock().await.new_handler(lifetime).map_err(|err| { |
| warn!("Could not initialize account handler: {:?}", err); |
| err.api_error |
| })?; |
| account_handler |
| .proxy() |
| .create_account(auth_mechanism_id.as_ref().map(|x| &**x)) |
| .await |
| .map_err(|err| { |
| warn!("Could not create account: {:?}", err); |
| ApiError::Resource |
| })??; |
| Ok(account_handler) |
| } |
| |
| async fn provision_new_account( |
| &self, |
| lifetime: Lifetime, |
| auth_mechanism_id: Option<String>, |
| ) -> Result<FidlLocalAccountId, ApiError> { |
| let account_handler = self.create_account_internal(lifetime, auth_mechanism_id).await?; |
| let account_id = account_handler.get_account_id(); |
| |
| // Persist the account both in memory and on disk |
| if let Err(err) = self.add_account(account_handler.clone()).await { |
| warn!("Failure adding account: {:?}", err); |
| account_handler.terminate().await; |
| Err(err.api_error) |
| } else { |
| info!("Adding new local account {:?}", account_id); |
| Ok(account_id.clone().into()) |
| } |
| } |
| |
| async fn provision_from_auth_provider( |
| &self, |
| auth_context_provider: ClientEnd<AuthenticationContextProviderMarker>, |
| auth_provider_type: String, |
| lifetime: Lifetime, |
| auth_mechanism_id: Option<String>, |
| ) -> Result<FidlLocalAccountId, ApiError> { |
| let account_handler = self.create_account_internal(lifetime, auth_mechanism_id).await?; |
| let account_id = account_handler.get_account_id(); |
| |
| // Add a service provider to the account |
| let _user_profile = match Self::add_service_provider_account( |
| auth_context_provider, |
| auth_provider_type, |
| Arc::clone(&account_handler), |
| ) |
| .await |
| { |
| Ok(user_profile) => user_profile, |
| Err(err) => { |
| // TODO(dnordstrom): Remove the newly created account handler as a cleanup. |
| warn!("Failure adding service provider account: {:?}", err); |
| account_handler.terminate().await; |
| return Err(err.api_error); |
| } |
| }; |
| |
| // Persist the account both in memory and on disk |
| if let Err(err) = self.add_account(Arc::clone(&account_handler)).await { |
| warn!("Failure adding service provider account: {:?}", err); |
| account_handler.terminate().await; |
| Err(err.api_error) |
| } else { |
| info!("Adding new account {:?}", &account_id); |
| Ok(account_id.clone().into()) |
| } |
| } |
| |
| // Attach a service provider account to this Fuchsia account |
| async fn add_service_provider_account( |
| auth_context_provider: ClientEnd<AuthenticationContextProviderMarker>, |
| auth_provider_type: String, |
| account_handler: Arc<AHC>, |
| ) -> Result<UserProfileInfo, AccountManagerError> { |
| // Use account handler to get a channel to the account |
| let (account_client_end, account_server_end) = |
| create_endpoints().account_manager_error(ApiError::Resource)?; |
| account_handler.proxy().get_account(auth_context_provider, account_server_end).await??; |
| let account_proxy = |
| account_client_end.into_proxy().account_manager_error(ApiError::Resource)?; |
| |
| // Use the account to get the persona |
| let (persona_client_end, persona_server_end) = |
| create_endpoints().account_manager_error(ApiError::Resource)?; |
| account_proxy.get_default_persona(persona_server_end).await??; |
| let persona_proxy = |
| persona_client_end.into_proxy().account_manager_error(ApiError::Resource)?; |
| |
| // Use the persona to get the token manager |
| let (tm_client_end, tm_server_end) = |
| create_endpoints().account_manager_error(ApiError::Resource)?; |
| persona_proxy.get_token_manager(SELF_URL, tm_server_end).await??; |
| let tm_proxy = tm_client_end.into_proxy().account_manager_error(ApiError::Resource)?; |
| |
| // Use the token manager to authorize |
| let mut app_config = AppConfig { |
| auth_provider_type, |
| client_id: None, |
| client_secret: None, |
| redirect_uri: None, |
| }; |
| let fut = tm_proxy.authorize( |
| &mut app_config, |
| None, /* auth_ui_context */ |
| &mut APP_SCOPES.iter().map(|x| &**x), |
| None, /* user_profile_id */ |
| None, /* auth_code */ |
| ); |
| match fut.await? { |
| (AuthStatus::Ok, None) => Err(AccountManagerError::new(ApiError::Internal) |
| .with_cause(format_err!("Invalid response from token manager"))), |
| (AuthStatus::Ok, Some(user_profile)) => Ok(*user_profile), |
| (auth_status, _) => Err(AccountManagerError::from(auth_status)), |
| } |
| } |
| |
| // Add the account to the AccountManager, including persistent state. |
| async fn add_account(&self, account_handler: Arc<AHC>) -> Result<(), AccountManagerError> { |
| let mut account_map = self.account_map.lock().await; |
| |
| account_map.add_account(Arc::clone(&account_handler)).await.map_err(|err| { |
| warn!("Could not add account: {:?}", err); |
| // TODO(fxbug.dev/39829): Improve error mapping. |
| if err.api_error == ApiError::FailedPrecondition { |
| ApiError::Internal |
| } else { |
| err.api_error |
| } |
| })?; |
| let event = AccountEvent::AccountAdded(account_handler.get_account_id().clone()); |
| self.event_emitter.publish(&event).await; |
| Ok(()) |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use crate::account_handler_connection::AccountHandlerConnectionImpl; |
| use crate::stored_account_list::{StoredAccountList, StoredAccountMetadata}; |
| use fidl::endpoints::{create_request_stream, RequestStream}; |
| use fidl_fuchsia_identity_account::{ |
| AccountListenerRequest, AccountManagerProxy, AccountManagerRequestStream, |
| AuthChangeGranularity, InitialAccountState, Scenario, ThreatScenario, |
| }; |
| use fuchsia_async as fasync; |
| use fuchsia_inspect::{assert_inspect_tree, Inspector}; |
| use fuchsia_zircon as zx; |
| use futures::future::join; |
| use lazy_static::lazy_static; |
| use std::path::Path; |
| use tempfile::TempDir; |
| |
| type TestAccountManager = AccountManager<AccountHandlerConnectionImpl>; |
| |
| lazy_static! { |
| /// Configuration for a set of fake auth providers used for testing. |
| /// This can be populated later if needed. |
| static ref AUTH_PROVIDER_CONFIG: Vec<AuthProviderConfig> = vec![]; |
| |
| static ref AUTH_MECHANISM_IDS: Vec<String> = vec![]; |
| |
| static ref TEST_SCENARIO: Scenario = |
| Scenario { include_test: false, threat_scenario: ThreatScenario::BasicAttacker }; |
| |
| static ref TEST_GRANULARITY: AuthChangeGranularity = AuthChangeGranularity { |
| engagement_changes: true, |
| presence_changes: false, |
| summary_changes: true, |
| }; |
| } |
| |
| const FORCE_REMOVE_ON: bool = true; |
| |
| fn request_stream_test<TestFn, Fut>(account_manager: TestAccountManager, test_fn: TestFn) |
| where |
| TestFn: FnOnce(AccountManagerProxy, Arc<TestAccountManager>) -> Fut, |
| Fut: Future<Output = Result<(), Error>>, |
| { |
| let mut executor = fasync::Executor::new().expect("Failed to create executor"); |
| let (server_chan, client_chan) = zx::Channel::create().expect("Failed to create channel"); |
| let proxy = AccountManagerProxy::new(fasync::Channel::from_channel(client_chan).unwrap()); |
| let request_stream = AccountManagerRequestStream::from_channel( |
| fasync::Channel::from_channel(server_chan).unwrap(), |
| ); |
| |
| let account_manager_arc = Arc::new(account_manager); |
| let account_manager_clone = Arc::clone(&account_manager_arc); |
| // TODO(fxbug.dev/39745): Migrate off of fuchsia_async::spawn. |
| fasync::Task::spawn(async move { |
| account_manager_clone |
| .handle_requests_from_stream(request_stream) |
| .await |
| .unwrap_or_else(|err| panic!("Fatal error handling test request: {:?}", err)) |
| }) |
| .detach(); |
| |
| executor |
| .run_singlethreaded(test_fn(proxy, account_manager_arc)) |
| .expect("Executor run failed.") |
| } |
| |
| // Construct an account manager initialized with the supplied set of accounts. |
| fn create_accounts( |
| existing_ids: Vec<u64>, |
| data_dir: &Path, |
| inspector: &Inspector, |
| ) -> TestAccountManager { |
| let stored_account_list = existing_ids |
| .iter() |
| .map(|&id| StoredAccountMetadata::new(LocalAccountId::new(id))) |
| .collect(); |
| StoredAccountList::new(stored_account_list) |
| .save(data_dir) |
| .expect("Couldn't write account list"); |
| |
| read_accounts(data_dir, inspector) |
| } |
| |
| // Contructs an account manager that reads its accounts from the supplied directory. |
| fn read_accounts( |
| data_dir: &Path, |
| inspector: &Inspector, |
| ) -> AccountManager<AccountHandlerConnectionImpl> { |
| AccountManager::new( |
| data_dir.to_path_buf(), |
| &AUTH_PROVIDER_CONFIG, |
| &AUTH_MECHANISM_IDS, |
| inspector, |
| ) |
| .unwrap() |
| } |
| |
| /// Note: Many AccountManager methods launch instances of an AccountHandler. Since its |
| /// currently not convenient to mock out this component launching in Rust, we rely on the |
| /// hermetic component test to provide coverage for these areas and only cover the in-process |
| /// behavior with this unit-test. |
| |
| #[test] |
| fn test_new() { |
| let inspector = Inspector::new(); |
| let data_dir = TempDir::new().unwrap(); |
| request_stream_test( |
| AccountManager::new( |
| data_dir.path().into(), |
| &AUTH_PROVIDER_CONFIG, |
| &AUTH_MECHANISM_IDS, |
| &inspector, |
| ) |
| .unwrap(), |
| |proxy, _| async move { |
| assert_eq!(proxy.get_account_ids().await?.len(), 0); |
| Ok(()) |
| }, |
| ); |
| } |
| |
| #[test] |
| fn test_unsupported_scenario() { |
| let data_dir = TempDir::new().unwrap(); |
| request_stream_test( |
| create_accounts(vec![], data_dir.path(), &Inspector::new()), |
| |proxy, _test_object| async move { |
| assert_eq!(proxy.get_account_ids().await?.len(), 0); |
| assert_eq!( |
| proxy.get_account_auth_states(&mut TEST_SCENARIO.clone()).await?, |
| Err(ApiError::UnsupportedOperation) |
| ); |
| Ok(()) |
| }, |
| ); |
| } |
| |
| #[test] |
| fn test_initially_empty() { |
| let data_dir = TempDir::new().unwrap(); |
| let inspector = Inspector::new(); |
| request_stream_test( |
| create_accounts(vec![], data_dir.path(), &inspector), |
| |proxy, _test_object| async move { |
| assert_eq!(proxy.get_account_ids().await?.len(), 0); |
| assert_inspect_tree!(inspector, root: contains { |
| accounts: { |
| active: 0 as u64, |
| total: 0 as u64, |
| }, |
| listeners: { |
| active: 0 as u64, |
| events: 0 as u64, |
| total_opened: 0 as u64, |
| }, |
| }); |
| Ok(()) |
| }, |
| ); |
| } |
| |
| #[test] |
| fn test_remove_missing_account() { |
| // Manually create an account manager with one account. |
| let data_dir = TempDir::new().unwrap(); |
| let stored_account_list = |
| StoredAccountList::new(vec![StoredAccountMetadata::new(LocalAccountId::new(1))]); |
| stored_account_list.save(data_dir.path()).unwrap(); |
| let inspector = Inspector::new(); |
| request_stream_test(read_accounts(data_dir.path(), &inspector), |proxy, _test_object| { |
| async move { |
| // Try to delete a very different account from the one we added. |
| assert_eq!( |
| proxy.remove_account(LocalAccountId::new(42).into(), FORCE_REMOVE_ON).await?, |
| Err(ApiError::NotFound) |
| ); |
| assert_inspect_tree!(inspector, root: contains { |
| accounts: { |
| total: 1 as u64, |
| active: 0 as u64, |
| }, |
| }); |
| Ok(()) |
| } |
| }); |
| } |
| |
| /// Sets up an AccountListener which an init event. |
| #[test] |
| fn test_account_listener() { |
| let mut options = AccountListenerOptions { |
| initial_state: true, |
| add_account: true, |
| remove_account: true, |
| scenario: None, |
| granularity: None, |
| }; |
| |
| let data_dir = TempDir::new().unwrap(); |
| let inspector = Inspector::new(); |
| request_stream_test( |
| create_accounts(vec![1, 2], data_dir.path(), &inspector), |
| |proxy, _| { |
| async move { |
| let (client_end, mut stream) = |
| create_request_stream::<AccountListenerMarker>().unwrap(); |
| let serve_fut = async move { |
| let request = stream.try_next().await.expect("stream error"); |
| if let Some(AccountListenerRequest::OnInitialize { |
| account_states, |
| responder, |
| }) = request |
| { |
| assert_eq!( |
| account_states, |
| vec![ |
| InitialAccountState { account_id: 1, auth_state: None }, |
| InitialAccountState { account_id: 2, auth_state: None }, |
| ] |
| ); |
| responder.send().unwrap(); |
| } else { |
| panic!("Unexpected message received"); |
| }; |
| if let Some(_) = stream.try_next().await.expect("stream error") { |
| panic!("Unexpected message, channel should be closed"); |
| } |
| }; |
| let request_fut = async move { |
| // The registering itself triggers the init event. |
| assert_eq!( |
| proxy |
| .register_account_listener(client_end, &mut options) |
| .await |
| .unwrap(), |
| Ok(()) |
| ); |
| }; |
| join(request_fut, serve_fut).await; |
| Ok(()) |
| } |
| }, |
| ); |
| } |
| |
| /// Registers an account listener with invalid request arguments. |
| #[test] |
| fn test_account_listener_invalid_requests() { |
| let mut options = AccountListenerOptions { |
| initial_state: true, |
| add_account: true, |
| remove_account: true, |
| scenario: None, |
| granularity: Some(Box::new(TEST_GRANULARITY.clone())), |
| }; |
| |
| let data_dir = TempDir::new().unwrap(); |
| let inspector = Inspector::new(); |
| request_stream_test( |
| create_accounts(vec![1, 2], data_dir.path(), &inspector), |
| |proxy, _| async move { |
| let (client_end, _) = create_request_stream::<AccountListenerMarker>().unwrap(); |
| assert_eq!( |
| proxy.register_account_listener(client_end, &mut options).await?, |
| Err(ApiError::InvalidRequest) |
| ); |
| Ok(()) |
| }, |
| ); |
| } |
| |
| /// Registers an account listener with a scenario, which is currently unsupported. |
| #[test] |
| fn test_account_listener_scenario() { |
| let mut options = AccountListenerOptions { |
| initial_state: true, |
| add_account: true, |
| remove_account: true, |
| scenario: Some(Box::new(TEST_SCENARIO.clone())), |
| granularity: None, |
| }; |
| |
| let data_dir = TempDir::new().unwrap(); |
| let inspector = Inspector::new(); |
| request_stream_test( |
| create_accounts(vec![1, 2], data_dir.path(), &inspector), |
| |proxy, _| async move { |
| let (client_end, _) = create_request_stream::<AccountListenerMarker>().unwrap(); |
| assert_eq!( |
| proxy.register_account_listener(client_end, &mut options).await?, |
| Err(ApiError::UnsupportedOperation) |
| ); |
| Ok(()) |
| }, |
| ); |
| } |
| |
| /// Registers an account listener with a scenario and a granularity, which is currently |
| /// unsupported. |
| #[test] |
| fn test_account_listener_scenario_granularity() { |
| let mut options = AccountListenerOptions { |
| initial_state: true, |
| add_account: true, |
| remove_account: true, |
| scenario: Some(Box::new(TEST_SCENARIO.clone())), |
| granularity: Some(Box::new(TEST_GRANULARITY.clone())), |
| }; |
| |
| let data_dir = TempDir::new().unwrap(); |
| let inspector = Inspector::new(); |
| request_stream_test( |
| create_accounts(vec![1, 2], data_dir.path(), &inspector), |
| |proxy, _| async move { |
| let (client_end, _) = create_request_stream::<AccountListenerMarker>().unwrap(); |
| assert_eq!( |
| proxy.register_account_listener(client_end, &mut options).await?, |
| Err(ApiError::UnsupportedOperation) |
| ); |
| Ok(()) |
| }, |
| ); |
| } |
| } |
