feat: unify window chrome and managed workspace tabs
This commit is contained in:
+16
-497
@@ -895,17 +895,19 @@ impl Worker {
|
||||
));
|
||||
}
|
||||
};
|
||||
if !matches!(
|
||||
input.kind.as_str(),
|
||||
"click"
|
||||
| "focus"
|
||||
| "scroll"
|
||||
| "tab-activate"
|
||||
| "tab-close"
|
||||
| "tab-detach"
|
||||
| "tab-drop"
|
||||
| "window-close"
|
||||
) {
|
||||
if !input.kind.starts_with("developer-open:")
|
||||
&& !matches!(
|
||||
input.kind.as_str(),
|
||||
"click"
|
||||
| "focus"
|
||||
| "scroll"
|
||||
| "tab-activate"
|
||||
| "tab-close"
|
||||
| "tab-detach"
|
||||
| "tab-drop"
|
||||
| "window-close"
|
||||
)
|
||||
{
|
||||
return RequestProgress::Complete(error_response(
|
||||
StatusCode(400),
|
||||
"unsupported event kind",
|
||||
@@ -985,8 +987,8 @@ impl Worker {
|
||||
|| frame.session != input.session
|
||||
|| (input.kind != "window-close" && frame.layout_version != input.layout_version)
|
||||
|| frame.fault.is_some()
|
||||
|| if input.kind == "window-close" {
|
||||
false
|
||||
|| if input.kind == "window-close" || input.kind.starts_with("developer-open:") {
|
||||
input.mount != 0
|
||||
} else if matches!(
|
||||
input.kind.as_str(),
|
||||
"tab-activate" | "tab-close" | "tab-detach" | "tab-drop"
|
||||
@@ -1797,487 +1799,4 @@ fn add_header(response: &mut Response<std::io::Cursor<Vec<u8>>>, name: &str, val
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use std::{
|
||||
io::Write,
|
||||
net::{SocketAddr, TcpStream},
|
||||
sync::atomic::{AtomicUsize, Ordering},
|
||||
time::Duration,
|
||||
};
|
||||
|
||||
#[test]
|
||||
fn preserved_picture_close_does_not_retire_same_number_in_fresh_console_vm() {
|
||||
let (_, mut picture) = endor_host::ReplSession::load(
|
||||
include_str!("../examples/windows.endor"),
|
||||
"app.main",
|
||||
1,
|
||||
150,
|
||||
)
|
||||
.unwrap();
|
||||
picture.frame.session = 0;
|
||||
for view in picture.windows.values_mut() {
|
||||
view.frame.session = 0;
|
||||
}
|
||||
let mut fresh = endor_host::ReplSession::new(151).unwrap();
|
||||
assert!(
|
||||
fresh
|
||||
.execute("pending=Window()\nui.window().resize(0,600)", "app.main")
|
||||
.is_err()
|
||||
);
|
||||
assert!(fresh.accepts_window(2));
|
||||
let namespace = Arc::new(RwLock::new(NamespaceState {
|
||||
document: picture,
|
||||
submission: 1,
|
||||
runtime_session: 151,
|
||||
..NamespaceState::default()
|
||||
}));
|
||||
let mut worker = Worker {
|
||||
repl: Some((1, fresh)),
|
||||
next_session: 151,
|
||||
};
|
||||
let notify: Notify = Arc::new(|| {});
|
||||
namespace.write().unwrap().window_viewports.insert(
|
||||
2,
|
||||
crate::layout::Size {
|
||||
width: 800.0,
|
||||
height: 600.0,
|
||||
},
|
||||
);
|
||||
worker.refresh_viewport(&namespace, ¬ify);
|
||||
assert_eq!(
|
||||
namespace.read().unwrap().document.windows[&2].frame.session,
|
||||
0
|
||||
);
|
||||
let response = worker.close_inactive_window(
|
||||
&crate::events::Input {
|
||||
window: 2,
|
||||
session: 0,
|
||||
layout_version: 0,
|
||||
mount: 0,
|
||||
kind: "window-close".into(),
|
||||
point: None,
|
||||
delta: None,
|
||||
press_point: None,
|
||||
tab_drop: None,
|
||||
screen_position: None,
|
||||
},
|
||||
1,
|
||||
&namespace,
|
||||
¬ify,
|
||||
);
|
||||
assert_eq!(response.status_code(), StatusCode(200));
|
||||
assert!(namespace.read().unwrap().document.windows.is_empty());
|
||||
let runtime = &mut worker.repl.as_mut().unwrap().1;
|
||||
assert_eq!(runtime.id, 151);
|
||||
assert!(runtime.accepts_window(2));
|
||||
assert_eq!(
|
||||
runtime.execute("pending.id()", "app.main").unwrap().value,
|
||||
"2"
|
||||
);
|
||||
}
|
||||
|
||||
struct TestServer {
|
||||
server: Arc<Server>,
|
||||
address: SocketAddr,
|
||||
api: Option<thread::JoinHandle<()>>,
|
||||
}
|
||||
|
||||
impl TestServer {
|
||||
fn request(&self, method: &str, path: &str, body: &str) -> (u16, String, String) {
|
||||
let mut stream = TcpStream::connect(self.address).unwrap();
|
||||
stream
|
||||
.set_read_timeout(Some(Duration::from_secs(10)))
|
||||
.unwrap();
|
||||
stream
|
||||
.set_write_timeout(Some(Duration::from_secs(10)))
|
||||
.unwrap();
|
||||
write!(stream, "{method} {path} HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\nContent-Type: text/plain; charset=utf-8\r\nContent-Length: {}\r\n\r\n{body}", body.len()).unwrap();
|
||||
let mut response = String::new();
|
||||
stream.read_to_string(&mut response).unwrap();
|
||||
let (headers, body) = response.split_once("\r\n\r\n").unwrap();
|
||||
let status = headers.split_whitespace().nth(1).unwrap().parse().unwrap();
|
||||
(status, headers.to_owned(), body.to_owned())
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for TestServer {
|
||||
fn drop(&mut self) {
|
||||
self.server.unblock();
|
||||
if let Some(api) = self.api.take() {
|
||||
let _ = api.join();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn native_tab_drop_route_reorders_live_pages_and_rejects_reused_frames() {
|
||||
let server = Arc::new(Server::http("127.0.0.1:0").unwrap());
|
||||
let namespace = Arc::new(RwLock::new(NamespaceState::default()));
|
||||
let api = start_server(server.clone(), namespace.clone(), Arc::new(|| {})).unwrap();
|
||||
let client = TestServer {
|
||||
address: server.server_addr().to_ip().unwrap(),
|
||||
server,
|
||||
api: Some(api),
|
||||
};
|
||||
let source = r#"class Tracked: Page {
|
||||
calls: Object
|
||||
function moveTab(self: Tracked, position: Number): Page { self.calls.increment() return Page.moveTab(self,position) }
|
||||
}
|
||||
calls=ui.state(0)
|
||||
first=Tracked(calls)
|
||||
first.title="first"
|
||||
first.render(TextBlock("first"))
|
||||
second=Page()
|
||||
second.title="second"
|
||||
second.render(TextBlock("second"))
|
||||
first.activate()"#;
|
||||
let result = client.request("PUT", "/v1/namespaces/app.main/code", source);
|
||||
assert_eq!(result.0, 200, "{}", result.2);
|
||||
let input = {
|
||||
let current = namespace.read().unwrap();
|
||||
let frame = ¤t.document.frame;
|
||||
crate::events::Input {
|
||||
window: 1,
|
||||
session: frame.session,
|
||||
layout_version: frame.layout_version,
|
||||
mount: frame.tabs[0].id,
|
||||
kind: "tab-drop".into(),
|
||||
point: None,
|
||||
press_point: None,
|
||||
delta: None,
|
||||
screen_position: None,
|
||||
tab_drop: Some(crate::events::TabDrop {
|
||||
window: 1,
|
||||
layout_version: frame.layout_version,
|
||||
index: 2,
|
||||
}),
|
||||
}
|
||||
};
|
||||
let body = serde_json::to_string(&input).unwrap();
|
||||
let response = client.request("POST", "/v1/namespaces/app.main/events", &body);
|
||||
assert_eq!(response.0, 200, "{}", response.2);
|
||||
let response = client.request("POST", "/v1/namespaces/app.main/repl", "calls.value");
|
||||
let value: serde_json::Value = serde_json::from_str(&response.2).unwrap();
|
||||
assert_eq!(value["value"], "1");
|
||||
assert_eq!(
|
||||
namespace.read().unwrap().document.frame.tabs[1].title,
|
||||
"first"
|
||||
);
|
||||
assert_eq!(
|
||||
client
|
||||
.request("POST", "/v1/namespaces/app.main/events", &body)
|
||||
.0,
|
||||
409
|
||||
);
|
||||
assert!(namespace.read().unwrap().document.frame.fault.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn background_failure_preserves_its_cause_after_rejected_console_input() {
|
||||
let server = Arc::new(Server::http("127.0.0.1:0").unwrap());
|
||||
let namespace = Arc::new(RwLock::new(NamespaceState::default()));
|
||||
let api = start_server(server.clone(), namespace.clone(), Arc::new(|| {})).unwrap();
|
||||
let client = TestServer {
|
||||
address: server.server_addr().to_ip().unwrap(),
|
||||
server,
|
||||
api: Some(api),
|
||||
};
|
||||
let source = r#"class Failure {
|
||||
function stop(self: Failure): Unit { ui.window().resize(0,600) }
|
||||
}
|
||||
failure=Failure()
|
||||
page=Page()
|
||||
page.render(TextBlock("preserved"))
|
||||
task=ui.after(ui,"failure",0,failure.stop)"#;
|
||||
let result = client.request("PUT", "/v1/namespaces/app.main/code", source);
|
||||
assert_eq!(result.0, 200, "{}", result.2);
|
||||
let repl = "/v1/namespaces/app.main/repl";
|
||||
assert_eq!(client.request("POST", repl, "42").0, 422);
|
||||
let fault = namespace
|
||||
.read()
|
||||
.unwrap()
|
||||
.document
|
||||
.frame
|
||||
.fault
|
||||
.clone()
|
||||
.unwrap();
|
||||
assert!(fault.contains("window size"), "{fault}");
|
||||
assert!(fault.contains("stop"), "{fault}");
|
||||
assert_eq!(client.request("POST", repl, "42").0, 422);
|
||||
assert_eq!(
|
||||
namespace.read().unwrap().document.frame.fault.as_ref(),
|
||||
Some(&fault)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn console_keeps_memory_until_reset_or_complete_put_without_erasing_the_page() {
|
||||
let server = Arc::new(Server::http("127.0.0.1:0").unwrap());
|
||||
let namespace = Arc::new(RwLock::new(NamespaceState::default()));
|
||||
let api = start_server(server.clone(), namespace.clone(), Arc::new(|| {})).unwrap();
|
||||
let client = TestServer {
|
||||
address: server.server_addr().to_ip().unwrap(),
|
||||
server,
|
||||
api: Some(api),
|
||||
};
|
||||
let repl = "/v1/namespaces/app.main/repl";
|
||||
let code = "/v1/namespaces/app.main/code";
|
||||
let created = client.request("POST", repl, "title = ui.text(\"中文\")");
|
||||
assert_eq!(created.0, 200, "{}", created.2);
|
||||
let created: serde_json::Value = serde_json::from_str(&created.2).unwrap();
|
||||
assert_eq!(created["rendered"], false);
|
||||
assert_eq!(created["revision"], 0);
|
||||
let read: serde_json::Value =
|
||||
serde_json::from_str(&client.request("POST", repl, "title").2).unwrap();
|
||||
assert_eq!(read["value"], created["value"]);
|
||||
assert_eq!(
|
||||
client.request("POST", repl, "ui.page().render(title)").0,
|
||||
200
|
||||
);
|
||||
let snapshot = client.request("GET", code, "");
|
||||
assert!(
|
||||
snapshot
|
||||
.1
|
||||
.to_lowercase()
|
||||
.contains("x-tessera-source-kind: repl-transcript")
|
||||
);
|
||||
assert_eq!(namespace.read().unwrap().revision, 1);
|
||||
assert_eq!(client.request("DELETE", repl, "").0, 200);
|
||||
assert_eq!(client.request("GET", code, "").2, snapshot.2);
|
||||
assert_eq!(client.request("POST", repl, "title").0, 422);
|
||||
assert_eq!(namespace.read().unwrap().revision, 1);
|
||||
assert_eq!(client.request("POST", repl, "retained = 42").0, 200);
|
||||
assert_eq!(
|
||||
client
|
||||
.request("PUT", code, include_str!("../examples/page.endor"))
|
||||
.0,
|
||||
200
|
||||
);
|
||||
assert_eq!(client.request("POST", repl, "retained").0, 422);
|
||||
assert_eq!(namespace.read().unwrap().revision, 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn http_executes_real_endor_preserves_failed_updates_and_supports_delete() {
|
||||
let server = Arc::new(Server::http("127.0.0.1:0").unwrap());
|
||||
let namespace = Arc::new(RwLock::new(NamespaceState::default()));
|
||||
let notifications = Arc::new(AtomicUsize::new(0));
|
||||
let counter = notifications.clone();
|
||||
let notify: Notify = Arc::new(move || {
|
||||
counter.fetch_add(1, Ordering::SeqCst);
|
||||
});
|
||||
let api = start_server(server.clone(), namespace.clone(), notify).unwrap();
|
||||
let client = TestServer {
|
||||
address: server.server_addr().to_ip().unwrap(),
|
||||
server,
|
||||
api: Some(api),
|
||||
};
|
||||
let route = "/v1/namespaces/app.main/code";
|
||||
let example = include_str!("../examples/page.endor");
|
||||
let (status, _, guide) = client.request("GET", "/agent", "");
|
||||
assert_eq!(status, 200);
|
||||
assert!(guide.contains("let myui = ui.page()"));
|
||||
let (status, _, body) = client.request("PUT", route, example);
|
||||
assert_eq!(status, 200, "{body}");
|
||||
assert_eq!(
|
||||
serde_json::from_str::<serde_json::Value>(&body).unwrap()["revision"],
|
||||
1
|
||||
);
|
||||
let (status, headers, source) = client.request("GET", route, "");
|
||||
assert_eq!(status, 200);
|
||||
assert!(headers.to_lowercase().contains("x-tessera-revision: 1"));
|
||||
assert_eq!(source, example);
|
||||
let (status, _, body) =
|
||||
client.request("PUT", route, "function main(): View { return missing }");
|
||||
assert_eq!(status, 422, "{body}");
|
||||
assert_eq!(
|
||||
serde_json::from_str::<serde_json::Value>(&body).unwrap()["diagnostics"][0]["line"],
|
||||
1
|
||||
);
|
||||
assert_eq!(client.request("GET", route, "").2, example);
|
||||
let second = example.replace("Hello Endor", "Second");
|
||||
assert_eq!(client.request("PUT", route, &second).0, 200);
|
||||
assert_eq!(namespace.read().unwrap().revision, 2);
|
||||
assert_eq!(client.request("DELETE", route, "").0, 200);
|
||||
assert_eq!(client.request("GET", route, "").2, "");
|
||||
assert!(namespace.read().unwrap().document.frame.commands.is_empty());
|
||||
assert_eq!(client.request("PUT", route, example).0, 200);
|
||||
assert_eq!(namespace.read().unwrap().revision, 4);
|
||||
assert_eq!(
|
||||
client
|
||||
.request("PUT", "/v1/namespaces/other/code", example)
|
||||
.0,
|
||||
404
|
||||
);
|
||||
assert_eq!(notifications.load(Ordering::SeqCst), 4);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn queued_candidate_keeps_live_owner_until_delete_revokes_it() {
|
||||
let (runtime, document) = endor_host::ReplSession::load(
|
||||
"retained = ui.state(9)\npage = Page()\npage.render(ui.textOf(retained,\"value\"))",
|
||||
"app.main",
|
||||
1,
|
||||
277,
|
||||
)
|
||||
.unwrap();
|
||||
let namespace = Arc::new(RwLock::new(NamespaceState {
|
||||
document,
|
||||
submission: 2,
|
||||
runtime_session: runtime.id,
|
||||
..NamespaceState::default()
|
||||
}));
|
||||
let mut worker = Worker {
|
||||
repl: Some((1, runtime)),
|
||||
next_session: 277,
|
||||
};
|
||||
let notify: Notify = Arc::new(|| {});
|
||||
worker.refresh_viewport(&namespace, ¬ify);
|
||||
assert_eq!(worker.repl.as_ref().unwrap().0, 2);
|
||||
assert_eq!(
|
||||
worker
|
||||
.repl
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.1
|
||||
.execute("retained.value", "app.main")
|
||||
.unwrap()
|
||||
.value,
|
||||
"9"
|
||||
);
|
||||
{
|
||||
let mut current = namespace.write().unwrap();
|
||||
current.submission = 3;
|
||||
worker.preserve_live_owner(¤t);
|
||||
}
|
||||
assert_eq!(worker.repl.as_ref().unwrap().0, 3);
|
||||
namespace.write().unwrap().clear().unwrap();
|
||||
worker.refresh_viewport(&namespace, ¬ify);
|
||||
assert!(worker.repl.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn http_delete_remains_available_and_invalidates_queued_put() {
|
||||
use std::{
|
||||
sync::{Mutex, mpsc},
|
||||
time::Instant,
|
||||
};
|
||||
let server = Arc::new(Server::http("127.0.0.1:0").unwrap());
|
||||
let namespace = Arc::new(RwLock::new(NamespaceState::default()));
|
||||
let (entered_tx, entered_rx) = mpsc::channel();
|
||||
let (release_tx, release_rx) = mpsc::channel();
|
||||
let release_rx = Mutex::new(release_rx);
|
||||
let calls = AtomicUsize::new(0);
|
||||
let notify: Notify = Arc::new(move || {
|
||||
if calls.fetch_add(1, Ordering::SeqCst) == 0 {
|
||||
entered_tx.send(()).unwrap();
|
||||
release_rx.lock().unwrap().recv().unwrap();
|
||||
}
|
||||
});
|
||||
let api = start_server(server.clone(), namespace.clone(), notify).unwrap();
|
||||
let client = TestServer {
|
||||
address: server.server_addr().to_ip().unwrap(),
|
||||
server,
|
||||
api: Some(api),
|
||||
};
|
||||
// Unblock even if a test assertion fails, before scoped threads join.
|
||||
struct Release(mpsc::Sender<()>);
|
||||
impl Drop for Release {
|
||||
fn drop(&mut self) {
|
||||
let _ = self.0.send(());
|
||||
}
|
||||
}
|
||||
thread::scope(|scope| {
|
||||
let release = Release(release_tx);
|
||||
let client = &client;
|
||||
let route = "/v1/namespaces/app.main/code";
|
||||
let example = include_str!("../examples/page.endor");
|
||||
let first = scope.spawn(move || client.request("PUT", route, example));
|
||||
entered_rx.recv_timeout(Duration::from_secs(10)).unwrap();
|
||||
let pending = scope.spawn(move || client.request("PUT", route, example));
|
||||
let deadline = Instant::now() + Duration::from_secs(10);
|
||||
while namespace.read().unwrap().submission < 2 {
|
||||
assert!(Instant::now() < deadline, "second PUT was not admitted");
|
||||
thread::sleep(Duration::from_millis(5));
|
||||
}
|
||||
assert_eq!(client.request("GET", route, "").2, example);
|
||||
assert_eq!(client.request("DELETE", route, "").0, 200);
|
||||
drop(release);
|
||||
assert_eq!(first.join().unwrap().0, 200);
|
||||
assert_eq!(pending.join().unwrap().0, 409);
|
||||
assert_eq!(client.request("GET", route, "").2, "");
|
||||
assert_eq!(namespace.read().unwrap().revision, 2);
|
||||
});
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn extracts_namespace_only_from_code_routes() {
|
||||
assert_eq!(
|
||||
namespace_from_path("/v1/namespaces/app.main/code"),
|
||||
Some("app.main")
|
||||
);
|
||||
assert_eq!(namespace_from_path("/v1/namespaces/app.main"), None);
|
||||
assert_eq!(namespace_from_path("/v1/namespaces/a/b/code"), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn guide_contains_only_code_crud_routes() {
|
||||
let guide = agent_guide(&NamespaceState::default());
|
||||
assert!(guide.contains("Code CRUD"));
|
||||
assert!(guide.contains("let myui = ui.page()"));
|
||||
assert!(!guide.contains("export scene"));
|
||||
assert!(guide.contains("PUT http://127.0.0.1:4737"));
|
||||
assert!(!guide.contains("display_list"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn foreground_refresh_does_not_deliver_new_callbacks_ahead_of_input() {
|
||||
let source = r#"
|
||||
class Action {
|
||||
count: Object
|
||||
function fire(self: Action): Unit { self.count.increment() }
|
||||
}
|
||||
count=ui.state(0)
|
||||
action=Action(count)
|
||||
ui.after(ui,"ready",0,action.fire)
|
||||
page=Page()
|
||||
page.render(TextBlock("input priority"))
|
||||
"#;
|
||||
let (runtime, document) =
|
||||
endor_host::ReplSession::load(source, "app.main", 1, 801).unwrap();
|
||||
let namespace = Arc::new(RwLock::new(NamespaceState {
|
||||
document,
|
||||
submission: 1,
|
||||
runtime_session: 801,
|
||||
..NamespaceState::default()
|
||||
}));
|
||||
let mut worker = Worker {
|
||||
repl: Some((1, runtime)),
|
||||
next_session: 801,
|
||||
};
|
||||
let notify: Notify = Arc::new(|| {});
|
||||
worker.refresh_viewport_mode(&namespace, ¬ify, true);
|
||||
let value = worker
|
||||
.repl
|
||||
.as_mut()
|
||||
.unwrap()
|
||||
.1
|
||||
.execute("count.value", "app.main")
|
||||
.unwrap()
|
||||
.value;
|
||||
assert_eq!(value, "0");
|
||||
worker.refresh_viewport(&namespace, ¬ify);
|
||||
let runtime = &mut worker.repl.as_mut().unwrap().1;
|
||||
for _ in 0..64 {
|
||||
if !runtime.has_pending_refresh() {
|
||||
break;
|
||||
}
|
||||
runtime
|
||||
.resize_windows_incremental(&std::collections::BTreeMap::new(), false)
|
||||
.unwrap();
|
||||
}
|
||||
let value = runtime.execute("count.value", "app.main").unwrap().value;
|
||||
assert_eq!(value, "1");
|
||||
}
|
||||
}
|
||||
mod tests;
|
||||
|
||||
Reference in New Issue
Block a user