678 lines
21 KiB
Rust
678 lines
21 KiB
Rust
use crate::{
|
|
executor,
|
|
geometry::vector::Vector2F,
|
|
keymap_matcher::{Binding, Keystroke},
|
|
platform,
|
|
platform::{Event, InputHandler, KeyDownEvent, Platform},
|
|
Action, AppContext, BorrowAppContext, BorrowWindowContext, Entity, FontCache, Handle,
|
|
ModelContext, ModelHandle, Subscription, Task, View, ViewContext, ViewHandle, WeakHandle,
|
|
WindowContext,
|
|
};
|
|
use collections::BTreeMap;
|
|
use futures::Future;
|
|
use itertools::Itertools;
|
|
use parking_lot::{Mutex, RwLock};
|
|
use smallvec::SmallVec;
|
|
use smol::stream::StreamExt;
|
|
use std::{
|
|
any::Any,
|
|
cell::RefCell,
|
|
mem,
|
|
path::PathBuf,
|
|
rc::Rc,
|
|
sync::{
|
|
atomic::{AtomicUsize, Ordering},
|
|
Arc,
|
|
},
|
|
time::Duration,
|
|
};
|
|
|
|
use super::{
|
|
ref_counts::LeakDetector, window_input_handler::WindowInputHandler, AsyncAppContext, RefCounts,
|
|
};
|
|
|
|
#[derive(Clone)]
|
|
pub struct TestAppContext {
|
|
cx: Rc<RefCell<AppContext>>,
|
|
foreground_platform: Rc<platform::test::ForegroundPlatform>,
|
|
condition_duration: Option<Duration>,
|
|
pub function_name: String,
|
|
assertion_context: AssertionContextManager,
|
|
}
|
|
|
|
impl TestAppContext {
|
|
pub fn new(
|
|
foreground_platform: Rc<platform::test::ForegroundPlatform>,
|
|
platform: Arc<dyn Platform>,
|
|
foreground: Rc<executor::Foreground>,
|
|
background: Arc<executor::Background>,
|
|
font_cache: Arc<FontCache>,
|
|
leak_detector: Arc<Mutex<LeakDetector>>,
|
|
first_entity_id: usize,
|
|
function_name: String,
|
|
) -> Self {
|
|
let mut cx = AppContext::new(
|
|
foreground,
|
|
background,
|
|
platform,
|
|
foreground_platform.clone(),
|
|
font_cache,
|
|
RefCounts::new(leak_detector),
|
|
(),
|
|
);
|
|
cx.next_entity_id = first_entity_id;
|
|
let cx = TestAppContext {
|
|
cx: Rc::new(RefCell::new(cx)),
|
|
foreground_platform,
|
|
condition_duration: None,
|
|
function_name,
|
|
assertion_context: AssertionContextManager::new(),
|
|
};
|
|
cx.cx.borrow_mut().weak_self = Some(Rc::downgrade(&cx.cx));
|
|
cx
|
|
}
|
|
|
|
pub fn dispatch_action<A: Action>(&mut self, window_id: usize, action: A) {
|
|
self.update_window(window_id, |window| {
|
|
window.dispatch_action(window.focused_view_id(), &action);
|
|
})
|
|
.expect("window not found");
|
|
}
|
|
|
|
pub fn available_actions(
|
|
&self,
|
|
window_id: usize,
|
|
view_id: usize,
|
|
) -> Vec<(&'static str, Box<dyn Action>, SmallVec<[Binding; 1]>)> {
|
|
self.read_window(window_id, |cx| cx.available_actions(view_id))
|
|
.unwrap_or_default()
|
|
}
|
|
|
|
pub fn dispatch_global_action<A: Action>(&mut self, action: A) {
|
|
self.update(|cx| cx.dispatch_global_action_any(&action));
|
|
}
|
|
|
|
pub fn dispatch_keystroke(&mut self, window_id: usize, keystroke: Keystroke, is_held: bool) {
|
|
let handled = self
|
|
.cx
|
|
.borrow_mut()
|
|
.update_window(window_id, |cx| {
|
|
if cx.dispatch_keystroke(&keystroke) {
|
|
return true;
|
|
}
|
|
|
|
if cx.dispatch_event(
|
|
Event::KeyDown(KeyDownEvent {
|
|
keystroke: keystroke.clone(),
|
|
is_held,
|
|
}),
|
|
false,
|
|
) {
|
|
return true;
|
|
}
|
|
|
|
false
|
|
})
|
|
.unwrap_or(false);
|
|
|
|
if !handled && !keystroke.cmd && !keystroke.ctrl {
|
|
WindowInputHandler {
|
|
app: self.cx.clone(),
|
|
window_id,
|
|
}
|
|
.replace_text_in_range(None, &keystroke.key)
|
|
}
|
|
}
|
|
|
|
pub fn read_window<T, F: FnOnce(&WindowContext) -> T>(
|
|
&self,
|
|
window_id: usize,
|
|
callback: F,
|
|
) -> Option<T> {
|
|
self.cx.borrow().read_window(window_id, callback)
|
|
}
|
|
|
|
pub fn update_window<T, F: FnOnce(&mut WindowContext) -> T>(
|
|
&mut self,
|
|
window_id: usize,
|
|
callback: F,
|
|
) -> Option<T> {
|
|
self.cx.borrow_mut().update_window(window_id, callback)
|
|
}
|
|
|
|
pub fn add_model<T, F>(&mut self, build_model: F) -> ModelHandle<T>
|
|
where
|
|
T: Entity,
|
|
F: FnOnce(&mut ModelContext<T>) -> T,
|
|
{
|
|
self.cx.borrow_mut().add_model(build_model)
|
|
}
|
|
|
|
pub fn add_window<T, F>(&mut self, build_root_view: F) -> (usize, ViewHandle<T>)
|
|
where
|
|
T: View,
|
|
F: FnOnce(&mut ViewContext<T>) -> T,
|
|
{
|
|
let (window_id, view) = self
|
|
.cx
|
|
.borrow_mut()
|
|
.add_window(Default::default(), build_root_view);
|
|
self.simulate_window_activation(Some(window_id));
|
|
(window_id, view)
|
|
}
|
|
|
|
pub fn add_window2<T, F>(&mut self, build_root_view: F) -> WindowHandle<T>
|
|
where
|
|
T: View,
|
|
F: FnOnce(&mut ViewContext<T>) -> T,
|
|
{
|
|
let (window_id, view) = self
|
|
.cx
|
|
.borrow_mut()
|
|
.add_window(Default::default(), build_root_view);
|
|
self.simulate_window_activation(Some(window_id));
|
|
(window_id, view)
|
|
}
|
|
|
|
pub fn add_view<T, F>(&mut self, window_id: usize, build_view: F) -> ViewHandle<T>
|
|
where
|
|
T: View,
|
|
F: FnOnce(&mut ViewContext<T>) -> T,
|
|
{
|
|
self.update_window(window_id, |cx| cx.add_view(build_view))
|
|
.expect("window not found")
|
|
}
|
|
|
|
pub fn observe_global<E, F>(&mut self, callback: F) -> Subscription
|
|
where
|
|
E: Any,
|
|
F: 'static + FnMut(&mut AppContext),
|
|
{
|
|
self.cx.borrow_mut().observe_global::<E, F>(callback)
|
|
}
|
|
|
|
pub fn set_global<T: 'static>(&mut self, state: T) {
|
|
self.cx.borrow_mut().set_global(state);
|
|
}
|
|
|
|
pub fn subscribe_global<E, F>(&mut self, callback: F) -> Subscription
|
|
where
|
|
E: Any,
|
|
F: 'static + FnMut(&E, &mut AppContext),
|
|
{
|
|
self.cx.borrow_mut().subscribe_global(callback)
|
|
}
|
|
|
|
pub fn window_ids(&self) -> Vec<usize> {
|
|
self.cx.borrow().windows.keys().copied().collect()
|
|
}
|
|
|
|
pub fn remove_all_windows(&mut self) {
|
|
self.update(|cx| cx.windows.clear());
|
|
}
|
|
|
|
pub fn read<T, F: FnOnce(&AppContext) -> T>(&self, callback: F) -> T {
|
|
callback(&*self.cx.borrow())
|
|
}
|
|
|
|
pub fn update<T, F: FnOnce(&mut AppContext) -> T>(&mut self, callback: F) -> T {
|
|
let mut state = self.cx.borrow_mut();
|
|
// Don't increment pending flushes in order for effects to be flushed before the callback
|
|
// completes, which is helpful in tests.
|
|
let result = callback(&mut *state);
|
|
// Flush effects after the callback just in case there are any. This can happen in edge
|
|
// cases such as the closure dropping handles.
|
|
state.flush_effects();
|
|
result
|
|
}
|
|
|
|
pub fn to_async(&self) -> AsyncAppContext {
|
|
AsyncAppContext(self.cx.clone())
|
|
}
|
|
|
|
pub fn font_cache(&self) -> Arc<FontCache> {
|
|
self.cx.borrow().font_cache.clone()
|
|
}
|
|
|
|
pub fn foreground_platform(&self) -> Rc<platform::test::ForegroundPlatform> {
|
|
self.foreground_platform.clone()
|
|
}
|
|
|
|
pub fn platform(&self) -> Arc<dyn platform::Platform> {
|
|
self.cx.borrow().platform.clone()
|
|
}
|
|
|
|
pub fn foreground(&self) -> Rc<executor::Foreground> {
|
|
self.cx.borrow().foreground().clone()
|
|
}
|
|
|
|
pub fn background(&self) -> Arc<executor::Background> {
|
|
self.cx.borrow().background().clone()
|
|
}
|
|
|
|
pub fn spawn<F, Fut, T>(&self, f: F) -> Task<T>
|
|
where
|
|
F: FnOnce(AsyncAppContext) -> Fut,
|
|
Fut: 'static + Future<Output = T>,
|
|
T: 'static,
|
|
{
|
|
let foreground = self.foreground();
|
|
let future = f(self.to_async());
|
|
let cx = self.to_async();
|
|
foreground.spawn(async move {
|
|
let result = future.await;
|
|
cx.0.borrow_mut().flush_effects();
|
|
result
|
|
})
|
|
}
|
|
|
|
pub fn simulate_new_path_selection(&self, result: impl FnOnce(PathBuf) -> Option<PathBuf>) {
|
|
self.foreground_platform.simulate_new_path_selection(result);
|
|
}
|
|
|
|
pub fn did_prompt_for_new_path(&self) -> bool {
|
|
self.foreground_platform.as_ref().did_prompt_for_new_path()
|
|
}
|
|
|
|
pub fn simulate_prompt_answer(&self, window_id: usize, answer: usize) {
|
|
use postage::prelude::Sink as _;
|
|
|
|
let mut done_tx = self
|
|
.platform_window_mut(window_id)
|
|
.pending_prompts
|
|
.borrow_mut()
|
|
.pop_front()
|
|
.expect("prompt was not called");
|
|
done_tx.try_send(answer).ok();
|
|
}
|
|
|
|
pub fn has_pending_prompt(&self, window_id: usize) -> bool {
|
|
let window = self.platform_window_mut(window_id);
|
|
let prompts = window.pending_prompts.borrow_mut();
|
|
!prompts.is_empty()
|
|
}
|
|
|
|
pub fn current_window_title(&self, window_id: usize) -> Option<String> {
|
|
self.platform_window_mut(window_id).title.clone()
|
|
}
|
|
|
|
pub fn simulate_window_close(&self, window_id: usize) -> bool {
|
|
let handler = self
|
|
.platform_window_mut(window_id)
|
|
.should_close_handler
|
|
.take();
|
|
if let Some(mut handler) = handler {
|
|
let should_close = handler();
|
|
self.platform_window_mut(window_id).should_close_handler = Some(handler);
|
|
should_close
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
|
|
pub fn simulate_window_resize(&self, window_id: usize, size: Vector2F) {
|
|
let mut window = self.platform_window_mut(window_id);
|
|
window.size = size;
|
|
let mut handlers = mem::take(&mut window.resize_handlers);
|
|
drop(window);
|
|
for handler in &mut handlers {
|
|
handler();
|
|
}
|
|
self.platform_window_mut(window_id).resize_handlers = handlers;
|
|
}
|
|
|
|
pub fn simulate_window_activation(&self, to_activate: Option<usize>) {
|
|
self.cx.borrow_mut().update(|cx| {
|
|
let other_window_ids = cx
|
|
.windows
|
|
.keys()
|
|
.filter(|window_id| Some(**window_id) != to_activate)
|
|
.copied()
|
|
.collect::<Vec<_>>();
|
|
|
|
for window_id in other_window_ids {
|
|
cx.window_changed_active_status(window_id, false)
|
|
}
|
|
|
|
if let Some(to_activate) = to_activate {
|
|
cx.window_changed_active_status(to_activate, true)
|
|
}
|
|
});
|
|
}
|
|
|
|
pub fn is_window_edited(&self, window_id: usize) -> bool {
|
|
self.platform_window_mut(window_id).edited
|
|
}
|
|
|
|
pub fn leak_detector(&self) -> Arc<Mutex<LeakDetector>> {
|
|
self.cx.borrow().leak_detector()
|
|
}
|
|
|
|
pub fn assert_dropped(&self, handle: impl WeakHandle) {
|
|
self.cx
|
|
.borrow()
|
|
.leak_detector()
|
|
.lock()
|
|
.assert_dropped(handle.id())
|
|
}
|
|
|
|
/// Drop a handle, assuming it is the last. If it is not the last, panic with debug information about
|
|
/// where the stray handles were created.
|
|
pub fn drop_last<T, W: WeakHandle, H: Handle<T, Weak = W>>(&mut self, handle: H) {
|
|
let weak = handle.downgrade();
|
|
self.update(|_| drop(handle));
|
|
self.assert_dropped(weak);
|
|
}
|
|
|
|
fn platform_window_mut(&self, window_id: usize) -> std::cell::RefMut<platform::test::Window> {
|
|
std::cell::RefMut::map(self.cx.borrow_mut(), |state| {
|
|
let window = state.windows.get_mut(&window_id).unwrap();
|
|
let test_window = window
|
|
.platform_window
|
|
.as_any_mut()
|
|
.downcast_mut::<platform::test::Window>()
|
|
.unwrap();
|
|
test_window
|
|
})
|
|
}
|
|
|
|
pub fn set_condition_duration(&mut self, duration: Option<Duration>) {
|
|
self.condition_duration = duration;
|
|
}
|
|
|
|
pub fn condition_duration(&self) -> Duration {
|
|
self.condition_duration.unwrap_or_else(|| {
|
|
if std::env::var("CI").is_ok() {
|
|
Duration::from_secs(2)
|
|
} else {
|
|
Duration::from_millis(500)
|
|
}
|
|
})
|
|
}
|
|
|
|
pub fn assert_clipboard_content(&mut self, expected_content: Option<&str>) {
|
|
self.update(|cx| {
|
|
let actual_content = cx.read_from_clipboard().map(|item| item.text().to_owned());
|
|
let expected_content = expected_content.map(|content| content.to_owned());
|
|
assert_eq!(actual_content, expected_content);
|
|
})
|
|
}
|
|
|
|
pub fn add_assertion_context(&self, context: String) -> ContextHandle {
|
|
self.assertion_context.add_context(context)
|
|
}
|
|
|
|
pub fn assertion_context(&self) -> String {
|
|
self.assertion_context.context()
|
|
}
|
|
}
|
|
|
|
impl BorrowAppContext for TestAppContext {
|
|
fn read_with<T, F: FnOnce(&AppContext) -> T>(&self, f: F) -> T {
|
|
self.cx.borrow().read_with(f)
|
|
}
|
|
|
|
fn update<T, F: FnOnce(&mut AppContext) -> T>(&mut self, f: F) -> T {
|
|
self.cx.borrow_mut().update(f)
|
|
}
|
|
}
|
|
|
|
impl BorrowWindowContext for TestAppContext {
|
|
fn read_with<T, F: FnOnce(&WindowContext) -> T>(&self, window_id: usize, f: F) -> T {
|
|
self.cx
|
|
.borrow()
|
|
.read_window(window_id, f)
|
|
.expect("window was closed")
|
|
}
|
|
|
|
fn update<T, F: FnOnce(&mut WindowContext) -> T>(&mut self, window_id: usize, f: F) -> T {
|
|
self.cx
|
|
.borrow_mut()
|
|
.update_window(window_id, f)
|
|
.expect("window was closed")
|
|
}
|
|
}
|
|
|
|
impl<T: Entity> ModelHandle<T> {
|
|
pub fn next_notification(&self, cx: &TestAppContext) -> impl Future<Output = ()> {
|
|
let (tx, mut rx) = futures::channel::mpsc::unbounded();
|
|
let mut cx = cx.cx.borrow_mut();
|
|
let subscription = cx.observe(self, move |_, _| {
|
|
tx.unbounded_send(()).ok();
|
|
});
|
|
|
|
let duration = if std::env::var("CI").is_ok() {
|
|
Duration::from_secs(5)
|
|
} else {
|
|
Duration::from_secs(1)
|
|
};
|
|
|
|
let executor = cx.background().clone();
|
|
async move {
|
|
executor.start_waiting();
|
|
let notification = crate::util::timeout(duration, rx.next())
|
|
.await
|
|
.expect("next notification timed out");
|
|
drop(subscription);
|
|
notification.expect("model dropped while test was waiting for its next notification")
|
|
}
|
|
}
|
|
|
|
pub fn next_event(&self, cx: &TestAppContext) -> impl Future<Output = T::Event>
|
|
where
|
|
T::Event: Clone,
|
|
{
|
|
let (tx, mut rx) = futures::channel::mpsc::unbounded();
|
|
let mut cx = cx.cx.borrow_mut();
|
|
let subscription = cx.subscribe(self, move |_, event, _| {
|
|
tx.unbounded_send(event.clone()).ok();
|
|
});
|
|
|
|
let duration = if std::env::var("CI").is_ok() {
|
|
Duration::from_secs(5)
|
|
} else {
|
|
Duration::from_secs(1)
|
|
};
|
|
|
|
cx.foreground.start_waiting();
|
|
async move {
|
|
let event = crate::util::timeout(duration, rx.next())
|
|
.await
|
|
.expect("next event timed out");
|
|
drop(subscription);
|
|
event.expect("model dropped while test was waiting for its next event")
|
|
}
|
|
}
|
|
|
|
pub fn condition(
|
|
&self,
|
|
cx: &TestAppContext,
|
|
mut predicate: impl FnMut(&T, &AppContext) -> bool,
|
|
) -> impl Future<Output = ()> {
|
|
let (tx, mut rx) = futures::channel::mpsc::unbounded();
|
|
|
|
let mut cx = cx.cx.borrow_mut();
|
|
let subscriptions = (
|
|
cx.observe(self, {
|
|
let tx = tx.clone();
|
|
move |_, _| {
|
|
tx.unbounded_send(()).ok();
|
|
}
|
|
}),
|
|
cx.subscribe(self, {
|
|
move |_, _, _| {
|
|
tx.unbounded_send(()).ok();
|
|
}
|
|
}),
|
|
);
|
|
|
|
let cx = cx.weak_self.as_ref().unwrap().upgrade().unwrap();
|
|
let handle = self.downgrade();
|
|
let duration = if std::env::var("CI").is_ok() {
|
|
Duration::from_secs(5)
|
|
} else {
|
|
Duration::from_secs(1)
|
|
};
|
|
|
|
async move {
|
|
crate::util::timeout(duration, async move {
|
|
loop {
|
|
{
|
|
let cx = cx.borrow();
|
|
let cx = &*cx;
|
|
if predicate(
|
|
handle
|
|
.upgrade(cx)
|
|
.expect("model dropped with pending condition")
|
|
.read(cx),
|
|
cx,
|
|
) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
cx.borrow().foreground().start_waiting();
|
|
rx.next()
|
|
.await
|
|
.expect("model dropped with pending condition");
|
|
cx.borrow().foreground().finish_waiting();
|
|
}
|
|
})
|
|
.await
|
|
.expect("condition timed out");
|
|
drop(subscriptions);
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: View> ViewHandle<T> {
|
|
pub fn next_notification(&self, cx: &TestAppContext) -> impl Future<Output = ()> {
|
|
use postage::prelude::{Sink as _, Stream as _};
|
|
|
|
let (mut tx, mut rx) = postage::mpsc::channel(1);
|
|
let mut cx = cx.cx.borrow_mut();
|
|
let subscription = cx.observe(self, move |_, _| {
|
|
tx.try_send(()).ok();
|
|
});
|
|
|
|
let duration = if std::env::var("CI").is_ok() {
|
|
Duration::from_secs(5)
|
|
} else {
|
|
Duration::from_secs(1)
|
|
};
|
|
|
|
async move {
|
|
let notification = crate::util::timeout(duration, rx.recv())
|
|
.await
|
|
.expect("next notification timed out");
|
|
drop(subscription);
|
|
notification.expect("model dropped while test was waiting for its next notification")
|
|
}
|
|
}
|
|
|
|
pub fn condition(
|
|
&self,
|
|
cx: &TestAppContext,
|
|
mut predicate: impl FnMut(&T, &AppContext) -> bool,
|
|
) -> impl Future<Output = ()> {
|
|
use postage::prelude::{Sink as _, Stream as _};
|
|
|
|
let (tx, mut rx) = postage::mpsc::channel(1024);
|
|
let timeout_duration = cx.condition_duration();
|
|
|
|
let mut cx = cx.cx.borrow_mut();
|
|
let subscriptions = (
|
|
cx.observe(self, {
|
|
let mut tx = tx.clone();
|
|
move |_, _| {
|
|
tx.blocking_send(()).ok();
|
|
}
|
|
}),
|
|
cx.subscribe(self, {
|
|
let mut tx = tx.clone();
|
|
move |_, _, _| {
|
|
tx.blocking_send(()).ok();
|
|
}
|
|
}),
|
|
);
|
|
|
|
let cx = cx.weak_self.as_ref().unwrap().upgrade().unwrap();
|
|
let handle = self.downgrade();
|
|
|
|
async move {
|
|
crate::util::timeout(timeout_duration, async move {
|
|
loop {
|
|
{
|
|
let cx = cx.borrow();
|
|
let cx = &*cx;
|
|
if predicate(
|
|
handle
|
|
.upgrade(cx)
|
|
.expect("view dropped with pending condition")
|
|
.read(cx),
|
|
cx,
|
|
) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
cx.borrow().foreground().start_waiting();
|
|
rx.recv()
|
|
.await
|
|
.expect("view dropped with pending condition");
|
|
cx.borrow().foreground().finish_waiting();
|
|
}
|
|
})
|
|
.await
|
|
.expect("condition timed out");
|
|
drop(subscriptions);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Tracks string context to be printed when assertions fail.
|
|
/// Often this is done by storing a context string in the manager and returning the handle.
|
|
#[derive(Clone)]
|
|
pub struct AssertionContextManager {
|
|
id: Arc<AtomicUsize>,
|
|
contexts: Arc<RwLock<BTreeMap<usize, String>>>,
|
|
}
|
|
|
|
impl AssertionContextManager {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
id: Arc::new(AtomicUsize::new(0)),
|
|
contexts: Arc::new(RwLock::new(BTreeMap::new())),
|
|
}
|
|
}
|
|
|
|
pub fn add_context(&self, context: String) -> ContextHandle {
|
|
let id = self.id.fetch_add(1, Ordering::Relaxed);
|
|
let mut contexts = self.contexts.write();
|
|
contexts.insert(id, context);
|
|
ContextHandle {
|
|
id,
|
|
manager: self.clone(),
|
|
}
|
|
}
|
|
|
|
pub fn context(&self) -> String {
|
|
let contexts = self.contexts.read();
|
|
format!("\n{}\n", contexts.values().join("\n"))
|
|
}
|
|
}
|
|
|
|
/// Used to track the lifetime of a piece of context so that it can be provided when an assertion fails.
|
|
/// For example, in the EditorTestContext, `set_state` returns a context handle so that if an assertion fails,
|
|
/// the state that was set initially for the failure can be printed in the error message
|
|
pub struct ContextHandle {
|
|
id: usize,
|
|
manager: AssertionContextManager,
|
|
}
|
|
|
|
impl Drop for ContextHandle {
|
|
fn drop(&mut self) {
|
|
let mut contexts = self.manager.contexts.write();
|
|
contexts.remove(&self.id);
|
|
}
|
|
}
|