public/galaxy
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
cc49d36c791f9cbe9e2b6b536a32a0f7a03448bf
galaxy/app/src/notebooks/notebook_tests.rs
T

935 lines
34 KiB
Rust
Raw Blame History

use std::sync::Arc;
use chrono::{Duration, Utc};
use futures_util::future::BoxFuture;
use galaxy_core::ui::appearance::Appearance;
use galaxy_editor::editor::EditorView;
use galaxyui::platform::WindowStyle;
use galaxyui::presenter::ChildView;
use galaxyui::r#async::Timer;
use galaxyui::telemetry::EventPayload;
use galaxyui::{
AddSingletonModel, App, AppContext, Element, Entity, SingletonEntity, TypedActionView, View,
ViewHandle, WindowId,
};
use itertools::Itertools;
use super::{NotebookEvent, NotebookView, EDIT_WINDOW_DURATION, SAVE_PERIOD};
use crate::auth::auth_manager::AuthManager;
use crate::auth::user::{TEST_USER_EMAIL, TEST_USER_UID};
use crate::auth::{AuthStateProvider, UserUid};
use crate::cloud_object::model::actions::ObjectActions;
use crate::cloud_object::model::persistence::CloudModel;
use crate::cloud_object::model::view::{CloudViewModel, Editor, EditorState};
use crate::cloud_object::{
Owner, Revision, ServerCloudObject, ServerMetadata, ServerNotebook, ServerPermissions,
};
use crate::drive::OpenGalaxyDriveObjectSettings;
use crate::editor::{DisplayPoint, EditorAction, InteractionState, SelectAction};
use crate::network::NetworkStatus;
use crate::notebooks::active_notebook_data::Mode;
use crate::notebooks::editor::keys::NotebookKeybindings;
use crate::notebooks::editor::notebook_command::NotebookCommand;
use crate::notebooks::editor::view::EditorViewAction;
use crate::notebooks::notebook::FocusedComponent;
use crate::notebooks::{CloudNotebook, CloudNotebookModel, NotebookLocation};
use crate::pane_group::PaneEvent;
use crate::search::files::model::FileSearchModel;
use crate::server::cloud_objects::update_manager::{InitialLoadResponse, UpdateManager};
use crate::server::ids::ClientId;
use crate::server::ids::SyncId::ServerId;
use crate::server::server_api::ServerApiProvider;
use crate::server::sync_queue::{QueueItem, SyncQueue, SyncQueueEvent};
use crate::server::telemetry::context_provider::AppTelemetryContextProvider;
use crate::settings_view::keybindings::KeybindingChangedNotifier;
use crate::terminal::keys::TerminalKeybindings;
use crate::test_util::settings::initialize_settings_for_tests;
use crate::workflows::workflow::Workflow;
use crate::workflows::{WorkflowSource, WorkflowType};
use crate::workspace::ActiveSession;
use crate::workspaces::team_tester::TeamTesterStatus;
use crate::workspaces::user_profiles::{UserProfileWithUID, UserProfiles};
use crate::workspaces::user_workspaces::UserWorkspaces;
use crate::{GlobalResourceHandles, GlobalResourceHandlesProvider, PrivacySettings};
fn initialize_app(app: &mut App) {
initialize_settings_for_tests(app);
let global_resources = GlobalResourceHandles::mock(app);
app.add_singleton_model(|_| GlobalResourceHandlesProvider::new(global_resources));
app.add_singleton_model(CloudModel::mock);
app.add_singleton_model(|_| NetworkStatus::new());
app.add_singleton_model(|_| Appearance::mock());
app.add_singleton_model(|_| KeybindingChangedNotifier::new());
app.add_singleton_model(|_| repo_metadata::repositories::DetectedRepositories::default());
#[cfg(feature = "local_fs")]
app.add_singleton_model(repo_metadata::RepoMetadataModel::new);
app.add_singleton_model(FileSearchModel::new);
app.add_singleton_model(NotebookKeybindings::new);
app.add_singleton_model(TerminalKeybindings::new);
app.add_singleton_model(PrivacySettings::mock);
app.add_singleton_model(UserWorkspaces::default_mock);
app.add_singleton_model(SyncQueue::mock);
app.add_singleton_model(TeamTesterStatus::mock);
app.add_singleton_model(UpdateManager::mock);
app.add_singleton_model(CloudViewModel::mock);
app.add_singleton_model(|_| UserProfiles::new(vec![]));
app.add_singleton_model(|_| ServerApiProvider::new_for_test());
app.add_singleton_model(|_| ActiveSession::default());
app.add_singleton_model(|_| ObjectActions::new(Vec::new()));
app.add_singleton_model(|_| AuthStateProvider::new_for_test());
app.add_singleton_model(AppTelemetryContextProvider::new_context_provider);
app.add_singleton_model(AuthManager::new_for_test);
#[cfg(feature = "voice_input")]
app.add_singleton_model(voice_input::VoiceInput::new);
}
/// Container so that [`NotebookView`] can be registered as a typed action view.
struct Root {
notebook: ViewHandle<NotebookView>,
events: Vec<NotebookEvent>,
}
impl Entity for Root {
type Event = ();
}
impl View for Root {
fn ui_name() -> &'static str {
"Root"
}
fn render(&self, _: &AppContext) -> Box<dyn Element> {
ChildView::new(&self.notebook).finish()
}
}
impl TypedActionView for Root {
type Action = ();
}
fn create_notebook(app: &mut App) -> (WindowId, ViewHandle<NotebookView>, ViewHandle<Root>) {
let (window, root) = app.add_window(WindowStyle::NotStealFocus, |ctx| {
let notebook = ctx.add_typed_action_view(NotebookView::new);
ctx.subscribe_to_view(&notebook, |me: &mut Root, _, event, _| {
me.events.push(event.clone())
});
Root {
notebook,
events: Vec::new(),
}
});
let notebook = app.read(|ctx| root.as_ref(ctx).notebook.clone());
(window, notebook, root)
}
/// Opens a notebook in the given view.
fn open_notebook(
app: &mut App,
handle: &ViewHandle<NotebookView>,
notebook: CloudNotebook,
) -> BoxFuture<'static, ()> {
let load_future = handle.update(app, |view, ctx| {
view.load(notebook, &OpenGalaxyDriveObjectSettings::default(), ctx)
});
app.update(|ctx| ctx.await_spawned_future(load_future.future_id()))
}
fn cloud_notebook(title: impl Into<String>, data: impl Into<String>) -> CloudNotebook {
CloudNotebook::new_local(
CloudNotebookModel {
title: title.into(),
data: data.into(),
ai_document_id: None,
conversation_id: None,
},
Owner::mock_current_user(),
None,
ClientId::new(),
)
}
/// Mock a server notebook
fn mock_server_notebook(title: impl Into<String>, data: impl Into<String>) -> ServerNotebook {
let metadata_ts = Utc::now().into();
ServerNotebook::new(
ServerId(123.into()),
CloudNotebookModel {
title: title.into(),
data: data.into(),
ai_document_id: None,
conversation_id: None,
},
ServerMetadata {
uid: 123.into(),
revision: Revision::now(),
metadata_last_updated_ts: metadata_ts,
trashed_ts: None,
folder_id: None,
is_welcome_object: false,
creator_uid: None,
last_editor_uid: None,
current_editor_uid: None,
},
ServerPermissions {
space: Owner::mock_current_user(),
guests: Vec::new(),
anyone_link_sharing: None,
permissions_last_updated_ts: metadata_ts,
},
)
}
/// Send changed objects to [`UpdateManager`] so that tests requiring "up-to-date" metadata can run.
async fn initial_load(app: &mut App, updated_notebooks: impl Into<Vec<ServerNotebook>>) {
let response = InitialLoadResponse {
updated_notebooks: updated_notebooks.into(),
deleted_notebooks: Default::default(),
updated_workflows: Default::default(),
deleted_workflows: Default::default(),
updated_folders: Default::default(),
deleted_folders: Default::default(),
user_profiles: Default::default(),
updated_generic_string_objects: Default::default(),
deleted_generic_string_objects: Default::default(),
action_histories: Default::default(),
mcp_gallery: Default::default(),
};
let load_complete = UpdateManager::handle(app).update(app, |update_manager, ctx| {
update_manager.mock_initial_load(response, ctx);
update_manager.initial_load_complete()
});
load_complete.await
}
/// Wait for all edits to be saved.
async fn ensure_saved(app: &mut App, notebook_view: &ViewHandle<NotebookView>) {
loop {
let has_edits = notebook_view.read(app, |notebook, _| {
notebook.content_is_dirty || notebook.title_is_dirty
});
if has_edits {
Timer::after(SAVE_PERIOD).await;
} else {
break;
}
}
// Ensure that any updates from the debounced save were processed.
app.update(|_| ());
}
/// Test that command-block execution events are correctly translated into workflows.
#[test]
fn test_command_block_dispatches_event() {
App::test((), |mut app| async move {
initialize_app(&mut app);
initial_load(&mut app, []).await;
let (window, notebook, root) = create_notebook(&mut app);
open_notebook(
&mut app,
&notebook,
cloud_notebook(
"Test Notebook",
r#"A command:
```
echo hello
```
"#,
),
)
.await;
// First, make sure the editor is focused.
notebook.update(&mut app, |notebook, ctx| {
notebook.focus_input(ctx);
});
app.update(|ctx| {
let input = &notebook.as_ref(ctx).input;
let command = input
.as_ref(ctx)
.runnable_command_at(11.into(), ctx)
.expect("Command should exist")
.as_any()
.downcast_ref::<NotebookCommand>()
.expect("Should convert");
// Use the command's own to_workflow implementation to use as much of the real code
// path as possible.
let workflow = command
.to_workflow(ctx)
.expect("Can't convert command to a workflow");
ctx.dispatch_typed_action_for_view(
window,
input.id(),
&EditorViewAction::RunWorkflow(workflow),
);
});
app.read(|ctx| {
let events = &root.as_ref(ctx).events;
assert!(
events.contains(&NotebookEvent::RunWorkflow {
workflow: Arc::new(WorkflowType::Notebook(Workflow::new(
"Command from Test Notebook",
"echo hello"
))),
source: WorkflowSource::Notebook {
notebook_id: None,
team_uid: None,
location: NotebookLocation::PersonalCloud,
},
}),
"No RunWorkflow event in {events:#?}"
);
})
});
}
#[test]
fn test_focus_tracking() {
App::test((), |mut app| async move {
initialize_app(&mut app);
initial_load(&mut app, []).await;
let (window, notebook, root) = create_notebook(&mut app);
open_notebook(
&mut app,
&notebook,
cloud_notebook("Test Notebook", "This is a notebook"),
)
.await;
let (title_view, input_view) = notebook.read(&app, |notebook, _| {
(notebook.title.clone(), notebook.input.clone())
});
// Focus the title editor by selecting.
app.update(|ctx| {
ctx.dispatch_typed_action_for_view(
window,
title_view.id(),
&EditorAction::Select(SelectAction::begin(DisplayPoint::new(0, 4))),
);
});
app.read(|ctx| {
assert_eq!(
notebook.as_ref(ctx).last_focused_component,
FocusedComponent::Title
);
let events = &root.as_ref(ctx).events;
assert_eq!(
events,
&[
// This is from focusing the title editor.
NotebookEvent::Pane(PaneEvent::FocusSelf)
]
);
});
// When blurring the notebook and restoring focus, focus should go to the title editor.
root.update(&mut app, |_, ctx| ctx.focus_self());
notebook.update(&mut app, |notebook, ctx| notebook.focus(ctx));
assert_eq!(app.focused_view_id(window), Some(title_view.id()));
app.read(|ctx| {
let events = &root.as_ref(ctx).events;
assert_eq!(
events,
&[
// This is the prior focus event.
NotebookEvent::Pane(PaneEvent::FocusSelf),
// This is from focusing the title editor again.
NotebookEvent::Pane(PaneEvent::FocusSelf)
]
);
});
// Focus the input view, which should emit a focused event.
input_view.update(&mut app, |view, ctx| view.focus(ctx));
app.read(|ctx| {
assert_eq!(
notebook.as_ref(ctx).last_focused_component,
FocusedComponent::Input
);
let events = &root.as_ref(ctx).events;
assert_eq!(
events,
&[
// These are prior events.
NotebookEvent::Pane(PaneEvent::FocusSelf),
NotebookEvent::Pane(PaneEvent::FocusSelf),
// This is from focusing the input editor.
NotebookEvent::Pane(PaneEvent::FocusSelf),
]
);
});
// Now, focus should be restored to the input editor.
root.update(&mut app, |_, ctx| ctx.focus_self());
notebook.update(&mut app, |notebook, ctx| notebook.focus(ctx));
assert_eq!(app.focused_view_id(window), Some(input_view.id()));
});
}
#[test]
#[ignore]
fn test_edit_telemetry() {
fn edit_events() -> Vec<serde_json::Value> {
galaxyui::telemetry::flush_events()
.into_iter()
.filter_map(|event| match event.payload {
EventPayload::NamedEvent { name, value, .. } if name == "Notebook Edited" => value,
_ => None,
})
.collect_vec()
}
App::test((), |mut app| async move {
initialize_app(&mut app);
initial_load(&mut app, []).await;
let (_, notebook, _) = create_notebook(&mut app);
open_notebook(
&mut app,
&notebook,
cloud_notebook("Test Notebook", "This is a notebook"),
)
.await;
let input_view = notebook.read(&app, |notebook, _| notebook.input.clone());
// The notebook should show in edit mode, with telemetry recording.
notebook.update(&mut app, |notebook, ctx| {
notebook.grab_edit_access(true, ctx);
assert_eq!(
notebook.active_notebook_data.as_ref(ctx).mode,
Mode::Editing
);
assert!(notebook.edit_telemetry_handle.is_some());
notebook.focus_input(ctx);
});
// With no edits, there are no events.
ensure_saved(&mut app, &notebook).await;
Timer::after(2 * EDIT_WINDOW_DURATION).await;
assert!(edit_events().is_empty());
// Make a small edit, which should get reported as non-meaningful.
input_view.update(&mut app, |input, ctx| {
input.user_typed("Hi", ctx);
});
ensure_saved(&mut app, &notebook).await;
Timer::after(2 * EDIT_WINDOW_DURATION).await;
assert_eq!(
edit_events(),
vec![serde_json::json!({
"notebook_id": None::<()>,
"meaningful_change": false,
})]
);
// If we switch to view mode, we stop recording elemetry.
notebook.update(&mut app, |notebook, ctx| {
notebook.switch_to_view(ctx);
assert!(notebook.edit_telemetry_handle.is_none());
});
// Telemetry resumes when we switch to editing.
notebook.update(&mut app, |notebook, ctx| {
notebook.switch_to_edit(ctx);
notebook.focus_input(ctx);
assert!(notebook.edit_telemetry_handle.is_some());
});
// Finally, a meaningful edit is recorded as such.
input_view.update(&mut app, |input, ctx| {
input.user_typed(
"This is a very very very very long edit. This is a heavy notebook user.",
ctx,
);
});
ensure_saved(&mut app, &notebook).await;
Timer::after(2 * EDIT_WINDOW_DURATION).await;
assert_eq!(
edit_events(),
vec![serde_json::json!({
"notebook_id": None::<()>,
"meaningful_change": true,
})]
);
});
}
/// Test to make sure we eagerly enter edit mode when user is already the current editor
#[test]
fn test_eager_baton_grab_same_current_editor() {
App::test((), |mut app| async move {
initialize_app(&mut app);
// Complete the initial load so that grab-the-baton behavior applies.
initial_load(&mut app, vec![]).await;
let (_, notebook_view, _) = create_notebook(&mut app);
let mut cloud_notebook = cloud_notebook("Test Notebook", r#"A notebook"#);
// Set the current editor of the notebook to be the test notebook
cloud_notebook.metadata.current_editor_uid = Some(TEST_USER_UID.to_string().clone());
// Add the notebook to cloud model
CloudModel::handle(&app).update(&mut app, |model, _| {
model.add_object(cloud_notebook.id, cloud_notebook.clone())
});
// Open the notebook
open_notebook(&mut app, &notebook_view, cloud_notebook).await;
// Assert that the editor is the current editor from the test user email
notebook_view.update(&mut app, |notebook, ctx| {
assert_eq!(
notebook
.active_notebook_data
.as_ref(ctx)
.current_editor(ctx),
Some(Editor {
state: EditorState::CurrentUser,
email: Some(TEST_USER_EMAIL.to_string())
})
)
});
let mode = notebook_view.read(&app, |notebook, ctx| notebook.mode(ctx));
// Assert that we are in edit mode open since the editor is the current editor
assert_eq!(mode, Mode::Editing);
});
}
/// Test to make sure we do not eagerly enter edit mode when there is another editor
#[test]
fn test_not_eager_baton_grab_different_editor() {
App::test((), |mut app| async move {
initialize_app(&mut app);
// Complete the initial load so that grab-the-baton behavior applies.
initial_load(&mut app, vec![]).await;
let uid = "ian@warp.dev".to_string();
let email = "ian@warp.dev".to_string();
let (_, notebook_view, _) = create_notebook(&mut app);
let mut cloud_notebook = cloud_notebook("Test Notebook", r#"A notebook"#);
// Set the current editor of the notebook to be another email
cloud_notebook.metadata.current_editor_uid = Some(uid.clone());
UserProfiles::handle(&app).update(&mut app, |user_profiles, _| {
user_profiles.insert_profiles(&vec![UserProfileWithUID {
firebase_uid: UserUid::new(&uid),
display_name: Some(email.clone()),
email: email.clone(),
photo_url: "".to_string(),
}]);
});
// Add the notebook to cloud model
CloudModel::handle(&app).update(&mut app, |model, _| {
model.add_object(cloud_notebook.id, cloud_notebook.clone())
});
// Open the notebook
open_notebook(&mut app, &notebook_view, cloud_notebook).await;
// Assert that the editor is the other email
notebook_view.update(&mut app, |notebook, ctx| {
assert_eq!(
notebook
.active_notebook_data
.as_ref(ctx)
.current_editor(ctx),
Some(Editor {
state: EditorState::OtherUserActive,
email: Some(email)
})
)
});
let mode = notebook_view.read(&app, |notebook, ctx| notebook.mode(ctx));
// Assert that we are in view mode open since there is another editor
assert_eq!(mode, Mode::View);
});
}
/// Test to make sure we do not eagerly enter edit mode when another editor took the baton
/// while Warp was closed.
#[test]
fn test_baton_grab_editor_changed_offline() {
App::test((), |mut app| async move {
initialize_app(&mut app);
let other_uid = "ben@warp.dev";
let other_email = "ben@warp.dev";
let (_, notebook_view, _) = create_notebook(&mut app);
// Create a notebook with no editor.
let mut server_notebook = mock_server_notebook("Test Notebook", "Some text");
let cloud_notebook = CloudNotebook::new_from_server(server_notebook.clone());
// Add the notebook to the cloud model, with no editor.
CloudModel::handle(&app).update(&mut app, |cloud_model, _| {
cloud_model.add_object(cloud_notebook.id, cloud_notebook.clone());
});
// Open the notebook, before initial load has finished.
let open_future = open_notebook(&mut app, &notebook_view, cloud_notebook);
// In the meantime, complete initial load with a new editor.
server_notebook.metadata.metadata_last_updated_ts =
(Utc::now() + Duration::seconds(1)).into();
server_notebook.metadata.current_editor_uid = Some(other_uid.to_string());
UserProfiles::handle(&app).update(&mut app, |user_profiles, _| {
user_profiles.insert_profiles(&vec![UserProfileWithUID {
firebase_uid: UserUid::new(other_uid),
display_name: Some(other_email.to_string()),
email: other_email.to_string(),
photo_url: "".to_string(),
}]);
});
initial_load(&mut app, vec![server_notebook]).await;
// The notebook should load and not take the baton.
open_future.await;
notebook_view.read(&app, |notebook, ctx| {
assert_eq!(
notebook
.active_notebook_data
.as_ref(ctx)
.current_editor(ctx),
Some(Editor {
state: EditorState::OtherUserActive,
email: Some(other_email.to_string())
})
);
assert_eq!(notebook.mode_app_ctx(ctx), Mode::View);
})
});
}
/// Test to make sure we can eagerly grab the baton if the previous editor exits offline.
#[test]
fn test_baton_grab_editor_left_offline() {
App::test((), |mut app| async move {
initialize_app(&mut app);
let other_uid = "ben@warp.dev";
let (_, notebook_view, _) = create_notebook(&mut app);
// Create a notebook with an editor.
let mut server_notebook = mock_server_notebook("Test Notebook", "Some text");
server_notebook.metadata.current_editor_uid = Some(other_uid.to_string());
let cloud_notebook = CloudNotebook::new_from_server(server_notebook.clone());
// Add the notebook to the cloud model, with the saved editor.
CloudModel::handle(&app).update(&mut app, |cloud_model, _| {
cloud_model.add_object(cloud_notebook.id, cloud_notebook.clone());
});
// Open the notebook, before initial load has finished.
let open_future = open_notebook(&mut app, &notebook_view, cloud_notebook);
// In the meantime, complete initial load with no editor.
server_notebook.metadata.metadata_last_updated_ts =
(Utc::now() + Duration::seconds(1)).into();
server_notebook.metadata.current_editor_uid = None;
initial_load(&mut app, vec![server_notebook]).await;
// The notebook should load and take the baton.
open_future.await;
notebook_view.read(&app, |notebook, ctx| {
assert_eq!(
notebook
.active_notebook_data
.as_ref(ctx)
.current_editor(ctx),
Some(Editor {
state: EditorState::CurrentUser,
email: Some(TEST_USER_EMAIL.to_string())
})
);
assert_eq!(notebook.mode_app_ctx(ctx), Mode::Editing);
})
});
}
#[test]
fn test_close_with_pending_changes() {
App::test((), |mut app| async move {
initialize_app(&mut app);
initial_load(&mut app, vec![]).await;
// Stop dequeueing, so that we can verify the queue contents.
SyncQueue::handle(&app).update(&mut app, |sync_queue, _ctx| {
sync_queue.stop_dequeueing();
assert_eq!(sync_queue.queue().len(), 0);
});
// Create a notebook with a server ID, so it can be synced.
let cloud_notebook =
CloudNotebook::new_from_server(mock_server_notebook("Test", "Some text"));
let notebook_id = cloud_notebook.id;
CloudModel::handle(&app).update(&mut app, |cloud_model, _| {
cloud_model.add_object(cloud_notebook.id, cloud_notebook.clone());
});
let (_, notebook_view, _) = create_notebook(&mut app);
open_notebook(&mut app, &notebook_view, cloud_notebook).await;
// Edit the notebook. It should not be saved yet.
notebook_view.update(&mut app, |notebook: &mut NotebookView, ctx| {
notebook.input.update(ctx, |input, ctx| {
input.user_typed("Hello ", ctx);
})
});
app.read(|ctx| {
let object = CloudModel::as_ref(ctx)
.get_by_uid(&notebook_id.uid())
.expect("Notebook should exist");
assert!(!object.metadata().has_pending_content_changes());
});
// Closing the notebook should force a save.
notebook_view.update(&mut app, |notebook, ctx| notebook.on_detach(ctx));
app.read(|ctx| {
let object = CloudModel::as_ref(ctx)
.get_by_uid(&notebook_id.uid())
.expect("Notebook should exist");
assert!(object.metadata().has_pending_content_changes());
let sync_queue = SyncQueue::as_ref(ctx).queue();
assert_eq!(sync_queue.len(), 1);
match &sync_queue[0].1 {
QueueItem::UpdateNotebook { model, id, .. } => {
assert_eq!(model.title, "Test".to_string());
assert_eq!(model.data, "Hello Some text".to_string());
assert_eq!(id, &notebook_id);
}
other => panic!("Expected UpdateNotebook, got {other:?}"),
}
})
});
}
#[test]
fn test_close_unmodified() {
// If we close a notebook with no pending changes, it should not save.
App::test((), |mut app| async move {
initialize_app(&mut app);
initial_load(&mut app, vec![]).await;
// Stop dequeueing, so that we can verify the queue contents.
SyncQueue::handle(&app).update(&mut app, |sync_queue, _ctx| {
sync_queue.stop_dequeueing();
assert_eq!(sync_queue.queue().len(), 0);
});
// Create a notebook with a server ID, so it can be synced.
let cloud_notebook =
CloudNotebook::new_from_server(mock_server_notebook("Test", "Some text"));
let notebook_id = cloud_notebook.id;
CloudModel::handle(&app).update(&mut app, |cloud_model, _| {
cloud_model.add_object(cloud_notebook.id, cloud_notebook.clone());
});
let (_, notebook_view, _) = create_notebook(&mut app);
open_notebook(&mut app, &notebook_view, cloud_notebook).await;
// Close the notebook with no changes.
notebook_view.update(&mut app, |notebook, ctx| notebook.on_detach(ctx));
app.read(|ctx| {
let object = CloudModel::as_ref(ctx)
.get_by_uid(&notebook_id.uid())
.expect("Notebook should exist");
assert!(!object.metadata().has_pending_content_changes());
let sync_queue = SyncQueue::as_ref(ctx).queue();
assert!(sync_queue.is_empty());
})
});
}
#[test]
fn test_only_user_title_edits_synced() {
// This tests that we only sync user edits, and don't echo back received title changes.
App::test((), |mut app| async move {
initialize_app(&mut app);
initial_load(&mut app, vec![]).await;
// Stop dequeueing, so that we can verify the queue contents.
SyncQueue::handle(&app).update(&mut app, |sync_queue, _ctx| {
sync_queue.stop_dequeueing();
assert_eq!(sync_queue.queue().len(), 0);
});
let (_, notebook_view, _) = create_notebook(&mut app);
// Create a notebook with a server ID, so it can be synced.
let mut server_notebook = mock_server_notebook("Initial Title", "Notebook contents");
let cloud_notebook: CloudNotebook = CloudNotebook::new_from_server(server_notebook.clone());
CloudModel::handle(&app).update(&mut app, |cloud_model, _| {
cloud_model.add_object(cloud_notebook.id, cloud_notebook.clone());
});
open_notebook(&mut app, &notebook_view, cloud_notebook).await;
// When a new title comes in, we should update the buffer but not emit a change.
server_notebook.model.title = "New Title".to_string();
server_notebook.metadata.revision = (Utc::now() + Duration::seconds(2)).into();
CloudModel::handle(&app).update(&mut app, |cloud_model, ctx| {
cloud_model.upsert_from_server_notebook(server_notebook, ctx);
});
notebook_view.read(&app, |notebook, ctx| {
assert_eq!(notebook.title(ctx), "New Title");
assert!(!notebook.title_is_dirty);
});
// When the _user_ edits the title, that should be synced.
notebook_view.update(&mut app, |notebook, ctx| {
notebook.title.update(ctx, |title, ctx| {
title.user_insert("!!!", ctx);
});
});
// This is outside the `update` callback so that it runs after the event is dispatched.
notebook_view.read(&app, |notebook, _| {
assert!(notebook.title_is_dirty);
});
ensure_saved(&mut app, &notebook_view).await;
SyncQueue::handle(&app).read(&app, |sync_queue, _| match sync_queue.queue().first() {
Some((_, QueueItem::UpdateNotebook { model, .. })) => {
assert_eq!(model.title.as_str(), "New Title!!!");
}
other => panic!("Expected notebook title update, got {other:?}"),
});
});
}
#[test]
fn test_conflicting_notebook_read_only() {
App::test((), |mut app| async move {
initialize_app(&mut app);
initial_load(&mut app, vec![]).await;
let (_, notebook_view, _) = create_notebook(&mut app);
let mut server_notebook = mock_server_notebook("A Notebook", "Local Data");
let server_id = server_notebook.id;
let mut cloud_notebook: CloudNotebook =
CloudNotebook::new_from_server(server_notebook.clone());
server_notebook.model.data = "Remote Data".to_string();
cloud_notebook.set_conflicting_object(Arc::new(server_notebook.clone()));
CloudModel::handle(&app).update(&mut app, |cloud_model, _| {
cloud_model.add_object(cloud_notebook.id, cloud_notebook.clone());
});
open_notebook(&mut app, &notebook_view, cloud_notebook).await;
// The notebook should load into view mode.
app.read(|ctx| {
let active_notebook_data = notebook_view.as_ref(ctx).active_notebook_data.as_ref(ctx);
assert!(active_notebook_data.has_conflicts(ctx));
assert_eq!(active_notebook_data.mode, Mode::View);
assert_eq!(
notebook_view
.as_ref(ctx)
.input
.as_ref(ctx)
.interaction_state(ctx),
InteractionState::Selectable
);
});
// While there are conflicts, the user should not be able to start editing.
notebook_view.update(&mut app, |notebook_view, ctx| {
notebook_view.grab_edit_access_or_display_access_dialog(ctx);
assert!(
!notebook_view
.active_notebook_data
.as_ref(ctx)
.show_grab_edit_access_modal
);
assert_eq!(notebook_view.mode(ctx), Mode::View);
});
// Resolving the conflict should make the notebook editable again.
notebook_view.update(&mut app, |notebook_view, ctx| {
notebook_view.conflict_dialog_refresh_button_clicked(ctx);
assert_eq!(notebook_view.content(ctx), "Remote Data");
notebook_view.grab_edit_access_or_display_access_dialog(ctx);
assert_eq!(notebook_view.mode(ctx), Mode::Editing);
});
// If there's another conflict, the notebook should switch back to view mode.
// Trigger this via the SyncQueue so that the UpdateManager records the conflict in CloudModel.
SyncQueue::handle(&app).update(&mut app, |_, ctx| {
ctx.emit(SyncQueueEvent::ObjectUpdateRejected {
id: server_id.uid(),
object: ServerCloudObject::Notebook(server_notebook).into(),
});
});
notebook_view.read(&app, |notebook_view, ctx| {
assert!(notebook_view
.active_notebook_data
.as_ref(ctx)
.has_conflicts(ctx));
assert_eq!(notebook_view.mode(ctx), Mode::View);
})
});
}
#[test]
fn test_untitled_notebook() {
App::test((), |mut app| async move {
initialize_app(&mut app);
let (_, notebook, _) = create_notebook(&mut app);
notebook.update(&mut app, |notebook, ctx| {
notebook.open_new_notebook(None, Owner::mock_current_user(), None, ctx);
});
notebook.read(&app, |notebook, ctx| {
assert_eq!(notebook.title(ctx), "Untitled");
});
notebook.update(&mut app, |notebook, ctx| {
notebook.switch_to_edit(ctx);
notebook.focus_title(ctx);
notebook.title.update(ctx, |title, ctx| {
title.user_insert("My Notebook", ctx);
});
assert_eq!(notebook.title(ctx), "My Notebook");
});
});
}
Reference in New Issue View Git Blame Copy Permalink