Skip to content

World's first open-source enterprise world model.

Read nested Notion blocks so page imports keep their body text (#1085)

Daniel18bd2dd70b3f
diff --git a/crates/utopia-server/src/notion.rs b/crates/utopia-server/src/notion.rs
index 59062a4f..344e3a54 100644
--- a/crates/utopia-server/src/notion.rs
+++ b/crates/utopia-server/src/notion.rs
@@ -42,11 +42,12 @@ const NOTION_VERSION: &str = "2026-03-11";
/// 可以有几万页。
const MAX_PAGES_PER_SYNC: usize = 500;
-/// 每页最多取多少个 block。再深的页面截断,比让一次同步卡在一页上好。
+/// 每页所有层级合计最多取多少个 block,包含无文字容器。
+/// 再深的页面截断,比让一次同步卡在一页上好。
const MAX_BLOCKS_PER_PAGE: usize = 500;
/// 两次请求之间至少隔这么久。Notion 说的是「平均每秒三次」,取 350 毫秒留一点余量:
-/// 500 页的上限下一次同步最坏三分钟出头,比同步失败便宜得多。
+/// 总耗时还取决于每页的嵌套层级与分页数。
const MIN_INTERVAL: Duration = Duration::from_millis(350);
/// 一次请求撞上 429 最多等几回。`Retry-After` 通常是个位数秒,连等几回还在限流
/// 就不是节奏问题了,该把错误交出去。
@@ -82,11 +83,17 @@ fn client(token: &str) -> anyhow::Result<reqwest::Client> {
struct Paced {
http: reqwest::Client,
last: Option<Instant>,
+ // 私有地址入口让 HTTP 测试走真实取页和限流逻辑,不增加用户配置。
+ api_root: String,
}
impl Paced {
fn new(http: reqwest::Client) -> Self {
- Self { http, last: None }
+ Self {
+ http,
+ last: None,
+ api_root: "https://api.notion.com/v1".into(),
+ }
}
/// 发一次请求并解析 JSON。`what` 进日志和错误文案("search" / "blocks")。
@@ -162,6 +169,13 @@ fn retry_after(header: Option<&str>) -> Duration {
/// 表格里的每一行是一个页面,会在同一次搜索里出现。
pub async fn fetch(token: &str, query: Option<&str>) -> anyhow::Result<(Vec<NotionPage>, bool)> {
let mut http = Paced::new(client(token)?);
+ fetch_pages(&mut http, query).await
+}
+
+async fn fetch_pages(
+ http: &mut Paced,
+ query: Option<&str>,
+) -> anyhow::Result<(Vec<NotionPage>, bool)> {
let mut out = Vec::new();
let mut cursor: Option<String> = None;
let mut truncated = false;
@@ -178,11 +192,8 @@ pub async fn fetch(token: &str, query: Option<&str>) -> anyhow::Result<(Vec<Noti
body["start_cursor"] = serde_json::Value::String(c.clone());
}
- let v = http
- .send("search", |c| {
- c.post("https://api.notion.com/v1/search").json(&body)
- })
- .await?;
+ let url = format!("{}/search", http.api_root);
+ let v = http.send("search", |c| c.post(&url).json(&body)).await?;
for p in v["results"].as_array().unwrap_or(&vec![]).clone() {
// 回收站里的和归档的都不要——它们在界面上已经不算数了
@@ -195,7 +206,7 @@ pub async fn fetch(token: &str, query: Option<&str>) -> anyhow::Result<(Vec<Noti
}
let Some(id) = p["id"].as_str() else { continue };
let title = page_title(&p);
- let text = page_text(&mut http, id).await.unwrap_or_else(|e| {
+ let text = page_text(http, id).await.unwrap_or_else(|e| {
tracing::warn!(%id, error = %e, "notion page body could not be read, keeping the title only");
String::new()
});
@@ -251,25 +262,53 @@ fn page_title(page: &serde_json::Value) -> String {
/// 取一页的正文,逐层展开 block。
async fn page_text(http: &mut Paced, page_id: &str) -> anyhow::Result<String> {
let mut out = String::new();
- let mut n = 0usize;
+ let mut block_count = 0;
+ append_children(http, page_id, &mut out, &mut block_count).await?;
+ Ok(out)
+}
+
+/// 每个父块独立分页,先写父块,再读完子树,最后继续兄弟块。
+/// 输出和预算由整页共享;递归深度也受同一块数上限约束。
+async fn append_children(
+ http: &mut Paced,
+ parent_id: &str,
+ out: &mut String,
+ block_count: &mut usize,
+) -> anyhow::Result<()> {
let mut cursor: Option<String> = None;
- loop {
- let mut url = format!("https://api.notion.com/v1/blocks/{page_id}/children?page_size=100");
+ while *block_count < MAX_BLOCKS_PER_PAGE {
+ let mut url = format!(
+ "{}/blocks/{parent_id}/children?page_size=100",
+ http.api_root
+ );
if let Some(c) = &cursor {
url.push_str(&format!("&start_cursor={c}"));
}
let v = http.send("blocks", |c| c.get(&url)).await?;
for b in v["results"].as_array().unwrap_or(&vec![]) {
- if n >= MAX_BLOCKS_PER_PAGE {
- return Ok(out);
+ if *block_count >= MAX_BLOCKS_PER_PAGE {
+ return Ok(());
}
- n += 1;
+ *block_count += 1;
if let Some(line) = render_block(b) {
out.push_str(&line);
out.push('\n');
}
+ // 不能因父块没有 rich_text 而跳过 column 等容器。
+ // 独立页面由 search 单独摄入,数据库也不是父页正文的一部分。
+ let independent_content =
+ matches!(b["type"].as_str(), Some("child_page" | "child_database"));
+ if *block_count < MAX_BLOCKS_PER_PAGE
+ && b["has_children"].as_bool() == Some(true)
+ && !independent_content
+ {
+ let id = b["id"]
+ .as_str()
+ .context("notion blocks: child block is missing id")?;
+ Box::pin(append_children(http, id, out, block_count)).await?;
+ }
}
if v["has_more"].as_bool() != Some(true) {
break;
@@ -279,7 +318,7 @@ async fn page_text(http: &mut Paced, page_id: &str) -> anyhow::Result<String> {
break;
}
}
- Ok(out)
+ Ok(())
}
/// 把一个 block 渲染成一行文本。
@@ -341,6 +380,14 @@ fn slug(title: &str) -> String {
}
}
+#[cfg(test)]
+#[path = "notion_tests.rs"]
+mod traversal_tests;
+
+#[cfg(test)]
+#[path = "notion_resync_tests.rs"]
+mod resync_tests;
+
#[cfg(test)]
mod tests {
use super::*;
diff --git a/crates/utopia-server/src/notion_resync_tests.rs b/crates/utopia-server/src/notion_resync_tests.rs
new file mode 100644
index 00000000..6f350eae
--- /dev/null
+++ b/crates/utopia-server/src/notion_resync_tests.rs
@@ -0,0 +1,170 @@
+//! A page imported before nested traversal must gain its missing body on resync,
+//! even when Notion's edit timestamp has not changed.
+use super::{fetch_pages, Paced};
+use crate::ingest_sources::{ingest_item, IngestAction};
+use chrono::{DateTime, Utc};
+use serde_json::json;
+use std::sync::Arc;
+use utopia_store::documents;
+use uuid::Uuid;
+use wiremock::{matchers::method, matchers::path, Mock, MockServer, ResponseTemplate};
+
+#[tokio::test]
+async fn resync_adds_nested_body_without_a_new_edit_timestamp() -> anyhow::Result<()> {
+ let Some(url) = utopia_store::test_db::url() else {
+ return Ok(());
+ };
+ let pool = sqlx::PgPool::connect(&url).await?;
+ let (org, workspace, kb, source) = (
+ Uuid::now_v7(),
+ Uuid::now_v7(),
+ Uuid::now_v7(),
+ Uuid::now_v7(),
+ );
+ let result = async {
+ sqlx::query("INSERT INTO organizations(id,name) VALUES($1,'notion-resync-test')")
+ .bind(org)
+ .execute(&pool)
+ .await?;
+ sqlx::query("INSERT INTO workspaces(id,org_id,name) VALUES($1,$2,'notion-resync-test')")
+ .bind(workspace)
+ .bind(org)
+ .execute(&pool)
+ .await?;
+ sqlx::query(
+ "INSERT INTO knowledge_bases(id,workspace_id,name) VALUES($1,$2,'notion-resync-test')",
+ )
+ .bind(kb)
+ .bind(workspace)
+ .execute(&pool)
+ .await?;
+ sqlx::query("INSERT INTO sources(id,kb_id,kind,name) VALUES($1,$2,'notion','fixture')")
+ .bind(source)
+ .bind(kb)
+ .execute(&pool)
+ .await?;
+ let dir = tempfile::tempdir()?;
+ let config = utopia_core::config::AppConfig {
+ data_dir: dir.path().to_string_lossy().into_owned(),
+ ..Default::default()
+ };
+ let search = Arc::new(utopia_search::SearchIndex::open(
+ &dir.path().join("search"),
+ )?);
+ let state = crate::state::AppState::new(pool.clone(), &config, search, "test-only".into());
+ let edited: DateTime<Utc> = "2026-10-01T12:00:00Z".parse()?;
+ let external_key = "notion://page";
+ let old_body = "# Quarterly policy\n\nPolicy details\n";
+ let complete_body = "# Quarterly policy\n\nPolicy details\nRevenue was 42 million.\n";
+
+ // Seed exactly the body the old top-level-only reader would have stored.
+ let created = ingest_item(
+ &state,
+ kb,
+ source,
+ external_key,
+ "Quarterly-policy.md",
+ "text/markdown",
+ old_body.as_bytes(),
+ Some(edited),
+ )
+ .await?;
+ anyhow::ensure!(created == IngestAction::Created);
+ let original = documents::find_by_external_key(&pool, source, external_key)
+ .await?
+ .ok_or_else(|| anyhow::anyhow!("the original page was not persisted"))?;
+
+ let server = MockServer::start().await;
+ Mock::given(method("POST"))
+ .and(path("/search"))
+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+ "results": [{
+ "id": "page",
+ "properties": {"Name": {"type": "title", "title": [{"plain_text": "Quarterly policy"}]}},
+ "last_edited_time": "2026-10-01T12:00:00Z"
+ }],
+ "has_more": false
+ })))
+ .expect(2)
+ .mount(&server)
+ .await;
+ Mock::given(method("GET"))
+ .and(path("/blocks/page/children"))
+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+ "results": [{
+ "id": "toggle", "type": "toggle", "has_children": true,
+ "toggle": {"rich_text": [{"plain_text": "Policy details"}]}
+ }],
+ "has_more": false
+ })))
+ .expect(2)
+ .mount(&server)
+ .await;
+ Mock::given(method("GET"))
+ .and(path("/blocks/toggle/children"))
+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+ "results": [{
+ "id": "paragraph", "type": "paragraph", "has_children": false,
+ "paragraph": {"rich_text": [{"plain_text": "Revenue was 42 million."}]}
+ }],
+ "has_more": false
+ })))
+ .expect(2)
+ .mount(&server)
+ .await;
+ let mut http = Paced::new(reqwest::Client::builder().no_proxy().build()?);
+ http.api_root = server.uri();
+
+ for expected in [IngestAction::Updated, IngestAction::Unchanged] {
+ let (pages, truncated) = fetch_pages(&mut http, None).await?;
+ anyhow::ensure!(!truncated && pages.len() == 1);
+ let page = &pages[0];
+ anyhow::ensure!(page.external_key == external_key);
+ anyhow::ensure!(page.last_edited == Some(edited));
+ anyhow::ensure!(page.text == complete_body);
+ let action = ingest_item(
+ &state,
+ kb,
+ source,
+ &page.external_key,
+ &page.filename,
+ "text/markdown",
+ page.text.as_bytes(),
+ page.last_edited,
+ )
+ .await?;
+ anyhow::ensure!(action == expected, "expected {expected:?}, got {action:?}");
+ let updated = documents::find_by_external_key(&pool, source, external_key)
+ .await?
+ .ok_or_else(|| anyhow::anyhow!("the resynced page was not persisted"))?;
+ anyhow::ensure!(updated.id == original.id);
+ anyhow::ensure!(updated.external_key.as_deref() == Some(external_key));
+ anyhow::ensure!(updated.doc_time == original.doc_time);
+ anyhow::ensure!(updated.doc_time == Some(edited));
+ anyhow::ensure!(updated.sha256 != original.sha256);
+ anyhow::ensure!(state.blob.get(&updated.sha256).await? == complete_body.as_bytes());
+ anyhow::ensure!(state.blob.get(&original.sha256).await? == old_body.as_bytes());
+ let versions: Vec<(i32, String)> = sqlx::query_as(
+ "SELECT version, sha256 FROM document_versions WHERE document_id=$1 ORDER BY version",
+ )
+ .bind(updated.id)
+ .fetch_all(&pool)
+ .await?;
+ anyhow::ensure!(
+ versions == vec![(1, original.sha256.clone()), (2, updated.sha256)],
+ "resync must retain the old body and create exactly one new version"
+ );
+ }
+ Ok::<_, anyhow::Error>(())
+ }
+ .await;
+ sqlx::query("DELETE FROM knowledge_bases WHERE id=$1")
+ .bind(kb)
+ .execute(&pool)
+ .await?;
+ sqlx::query("DELETE FROM organizations WHERE id=$1")
+ .bind(org)
+ .execute(&pool)
+ .await?;
+ result
+}
diff --git a/crates/utopia-server/src/notion_tests.rs b/crates/utopia-server/src/notion_tests.rs
new file mode 100644
index 00000000..486fe4d1
--- /dev/null
+++ b/crates/utopia-server/src/notion_tests.rs
@@ -0,0 +1,457 @@
+use super::*;
+use serde_json::{json, Value};
+use std::sync::{Arc, Mutex};
+use wiremock::{matchers::method, matchers::path, Mock, MockServer, Request, ResponseTemplate};
+
+fn paced(server: &MockServer) -> Paced {
+ // 本地 mock 不走开发机的系统代理。
+ let mut http = Paced::new(reqwest::Client::builder().no_proxy().build().unwrap());
+ http.api_root = server.uri();
+ http
+}
+
+fn block(id: &str, kind: &str, text: &str, has_children: bool) -> Value {
+ json!({
+ "id": id, "type": kind, "has_children": has_children,
+ kind: {"rich_text": [{"plain_text": text}]}
+ })
+}
+
+async fn children(
+ server: &MockServer,
+ parent: &str,
+ cursor: Option<&str>,
+ blocks: Vec<Value>,
+ next_cursor: Option<&str>,
+) {
+ let cursor = cursor.map(str::to_owned);
+ Mock::given(method("GET"))
+ .and(path(format!("/blocks/{parent}/children")))
+ .and(move |request: &Request| {
+ let actual = request
+ .url
+ .query_pairs()
+ .find(|(key, _)| key == "start_cursor");
+ actual.map(|(_, value)| value.into_owned()) == cursor
+ })
+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+ "results": blocks, "has_more": next_cursor.is_some(), "next_cursor": next_cursor
+ })))
+ .expect(1)
+ .mount(server)
+ .await;
+}
+
+async fn request_paths(server: &MockServer) -> Vec<String> {
+ server
+ .received_requests()
+ .await
+ .unwrap()
+ .iter()
+ .map(|request| {
+ assert!(request
+ .url
+ .query_pairs()
+ .any(|(key, value)| key == "page_size" && value == "100"));
+ request.url.path().to_owned()
+ })
+ .collect()
+}
+
+#[tokio::test]
+async fn toggle_body_is_read_before_the_next_sibling() {
+ let server = MockServer::start().await;
+ children(
+ &server,
+ "page",
+ None,
+ vec![
+ block("toggle", "toggle", "Quarterly policy", true),
+ block("after", "paragraph", "After toggle", false),
+ ],
+ None,
+ )
+ .await;
+ children(
+ &server,
+ "toggle",
+ None,
+ vec![block(
+ "paragraph",
+ "paragraph",
+ "Revenue was 42 million.",
+ false,
+ )],
+ None,
+ )
+ .await;
+ assert_eq!(
+ page_text(&mut paced(&server), "page").await.unwrap(),
+ "Quarterly policy\nRevenue was 42 million.\nAfter toggle\n"
+ );
+ assert_eq!(
+ request_paths(&server).await,
+ ["/blocks/page/children", "/blocks/toggle/children"]
+ );
+}
+
+#[tokio::test]
+async fn columns_without_rich_text_keep_nested_body_in_reading_order() {
+ let server = MockServer::start().await;
+ children(
+ &server,
+ "page",
+ None,
+ vec![
+ json!({"id":"columns", "type":"column_list", "has_children":true, "column_list":{}}),
+ block("after", "paragraph", "After columns", false),
+ ],
+ None,
+ )
+ .await;
+ children(
+ &server,
+ "columns",
+ None,
+ vec![
+ json!({"id":"left", "type":"column", "has_children":true, "column":{}}),
+ json!({"id":"right", "type":"column", "has_children":true, "column":{}}),
+ ],
+ None,
+ )
+ .await;
+ children(
+ &server,
+ "left",
+ None,
+ vec![
+ block("nested", "toggle", "Left toggle", true),
+ block("left-after", "paragraph", "Left after", false),
+ ],
+ None,
+ )
+ .await;
+ children(
+ &server,
+ "nested",
+ None,
+ vec![block("body", "paragraph", "Deep body", false)],
+ None,
+ )
+ .await;
+ children(
+ &server,
+ "right",
+ None,
+ vec![block("right-body", "paragraph", "Right body", false)],
+ None,
+ )
+ .await;
+ assert_eq!(
+ page_text(&mut paced(&server), "page").await.unwrap(),
+ "Left toggle\nDeep body\nLeft after\nRight body\nAfter columns\n"
+ );
+ assert_eq!(
+ request_paths(&server).await,
+ [
+ "/blocks/page/children",
+ "/blocks/columns/children",
+ "/blocks/left/children",
+ "/blocks/nested/children",
+ "/blocks/right/children"
+ ]
+ );
+}
+
+#[tokio::test]
+async fn pagination_cursors_belong_to_each_parent() {
+ let server = MockServer::start().await;
+ children(
+ &server,
+ "page",
+ None,
+ vec![
+ block("a", "toggle", "A", true),
+ block("b", "toggle", "B", true),
+ ],
+ Some("root-next"),
+ )
+ .await;
+ children(
+ &server,
+ "a",
+ None,
+ vec![block("a1", "paragraph", "A1", false)],
+ Some("a-next"),
+ )
+ .await;
+ children(
+ &server,
+ "a",
+ Some("a-next"),
+ vec![block("a2", "paragraph", "A2", false)],
+ None,
+ )
+ .await;
+ children(
+ &server,
+ "b",
+ None,
+ vec![block("b1", "paragraph", "B1", false)],
+ Some("b-next"),
+ )
+ .await;
+ children(
+ &server,
+ "b",
+ Some("b-next"),
+ vec![block("b2", "paragraph", "B2", false)],
+ None,
+ )
+ .await;
+ children(
+ &server,
+ "page",
+ Some("root-next"),
+ vec![block("end", "paragraph", "End", false)],
+ None,
+ )
+ .await;
+ assert_eq!(
+ page_text(&mut paced(&server), "page").await.unwrap(),
+ "A\nA1\nA2\nB\nB1\nB2\nEnd\n"
+ );
+ assert_eq!(
+ request_paths(&server).await,
+ [
+ "/blocks/page/children",
+ "/blocks/a/children",
+ "/blocks/a/children",
+ "/blocks/b/children",
+ "/blocks/b/children",
+ "/blocks/page/children"
+ ]
+ );
+}
+
+#[tokio::test]
+async fn block_budget_is_shared_and_stops_before_any_further_request() {
+ let server = MockServer::start().await;
+ children(
+ &server,
+ "page",
+ None,
+ vec![
+ json!({"id":"container", "type":"column", "has_children":true, "column":{}}),
+ block("sibling", "toggle", "Must not appear", true),
+ ],
+ Some("root-next"),
+ )
+ .await;
+ // 无文字容器也占一块;子层第五页的第 99 块耗尽整页预算。
+ for page in 0..5 {
+ let cursor = format!("child-{page}");
+ let next = format!("child-{}", page + 1);
+ let blocks = (0..100)
+ .map(|index| {
+ let id = format!("item-{}", page * 100 + index);
+ block(&id, "paragraph", &id, page == 4 && index == 98)
+ })
+ .collect();
+ children(
+ &server,
+ "container",
+ if page == 0 { None } else { Some(&cursor) },
+ blocks,
+ Some(&next),
+ )
+ .await;
+ }
+ let text = page_text(&mut paced(&server), "page").await.unwrap();
+ assert_eq!(text.lines().count(), MAX_BLOCKS_PER_PAGE - 1);
+ assert!(text.ends_with("item-498\n"));
+ assert!(!text.contains("Must not appear"));
+ assert_eq!(request_paths(&server).await.len(), 6);
+}
+
+#[tokio::test]
+async fn exact_top_level_budget_does_not_fetch_another_page() {
+ let server = MockServer::start().await;
+ for page in 0..5 {
+ let cursor = format!("root-{page}");
+ let next = format!("root-{}", page + 1);
+ let blocks = (0..100)
+ .map(|index| block(&format!("{page}-{index}"), "paragraph", "Body", false))
+ .collect();
+ children(
+ &server,
+ "page",
+ if page == 0 { None } else { Some(&cursor) },
+ blocks,
+ Some(&next),
+ )
+ .await;
+ }
+ assert_eq!(
+ page_text(&mut paced(&server), "page")
+ .await
+ .unwrap()
+ .lines()
+ .count(),
+ MAX_BLOCKS_PER_PAGE
+ );
+ assert_eq!(request_paths(&server).await.len(), 5);
+}
+
+#[tokio::test]
+async fn independent_pages_and_databases_are_not_inlined() {
+ let server = MockServer::start().await;
+ children(&server, "page", None, vec![
+ json!({"id":"child", "type":"child_page", "has_children":true, "child_page":{"title":"Separate page"}}),
+ json!({"id":"database", "type":"child_database", "has_children":true, "child_database":{"title":"Separate database"}}),
+ block("body", "paragraph", "Parent body", false),
+ ], None).await;
+ assert_eq!(
+ page_text(&mut paced(&server), "page").await.unwrap(),
+ "- Separate page\nParent body\n"
+ );
+ assert_eq!(request_paths(&server).await, ["/blocks/page/children"]);
+}
+
+#[tokio::test]
+async fn flat_page_markdown_is_unchanged() {
+ let server = MockServer::start().await;
+ children(&server, "page", None, vec![
+ block("heading", "heading_1", "Heading", false),
+ block("paragraph", "paragraph", "Body", false),
+ block("bullet", "bulleted_list_item", "Bullet", false),
+ block("number", "numbered_list_item", "Number", false),
+ json!({"type":"to_do", "to_do":{"checked":true, "rich_text":[{"plain_text":"Done"}]}}),
+ block("quote", "quote", "Quote", false),
+ json!({"type":"code", "code":{"language":"rust", "rich_text":[{"plain_text":"let x = 1;"}]}}),
+ json!({"type":"divider", "divider":{}}),
+ block("unknown", "new_type", "Unknown text", false),
+ ], None).await;
+ assert_eq!(page_text(&mut paced(&server), "page").await.unwrap(),
+ "## Heading\nBody\n- Bullet\n1. Number\n- [x] Done\n> Quote\n```rust\nlet x = 1;\n```\nUnknown text\n");
+ assert_eq!(request_paths(&server).await.len(), 1);
+}
+
+#[tokio::test]
+async fn child_request_error_keeps_existing_diagnostics() {
+ let server = MockServer::start().await;
+ children(
+ &server,
+ "page",
+ None,
+ vec![block("child", "toggle", "Parent", true)],
+ None,
+ )
+ .await;
+ Mock::given(path("/blocks/child/children"))
+ .respond_with(
+ ResponseTemplate::new(403).set_body_json(json!({"message":"child access denied"})),
+ )
+ .expect(1)
+ .mount(&server)
+ .await;
+ let error = page_text(&mut paced(&server), "page").await.unwrap_err();
+ assert_eq!(
+ error.to_string(),
+ "notion blocks returned 403 Forbidden: child access denied"
+ );
+}
+
+#[tokio::test]
+async fn nested_requests_share_pacing_and_honor_retry_after() {
+ let server = MockServer::start().await;
+ let calls = Arc::new(Mutex::new(Vec::new()));
+ let recorded = calls.clone();
+ Mock::given(method("GET")).respond_with(move |request: &Request| {
+ let mut calls = recorded.lock().unwrap();
+ calls.push((request.url.path().to_owned(), Instant::now()));
+ match calls.len() {
+ 1 => ResponseTemplate::new(200).set_body_json(json!({"results":[block("child", "toggle", "Parent", true)], "has_more":false})),
+ 2 => ResponseTemplate::new(429).insert_header("Retry-After", "0.5").set_body_json(json!({"message":"slow down"})),
+ _ => ResponseTemplate::new(200).set_body_json(json!({"results":[block("body", "paragraph", "Child", false)], "has_more":false})),
+ }
+ }).expect(3).mount(&server).await;
+ assert_eq!(
+ page_text(&mut paced(&server), "page").await.unwrap(),
+ "Parent\nChild\n"
+ );
+ let calls = calls.lock().unwrap();
+ assert_eq!(
+ calls
+ .iter()
+ .map(|(path, _)| path.as_str())
+ .collect::<Vec<_>>(),
+ [
+ "/blocks/page/children",
+ "/blocks/child/children",
+ "/blocks/child/children"
+ ]
+ );
+ assert!(calls[1].1.duration_since(calls[0].1) >= MIN_INTERVAL);
+ assert!(calls[2].1.duration_since(calls[1].1) >= Duration::from_millis(500));
+}
+
+#[tokio::test]
+async fn child_rate_limit_exhaustion_is_an_error() {
+ let server = MockServer::start().await;
+ children(
+ &server,
+ "page",
+ None,
+ vec![block("child", "toggle", "Parent", true)],
+ None,
+ )
+ .await;
+ Mock::given(path("/blocks/child/children"))
+ .respond_with(
+ ResponseTemplate::new(429)
+ .insert_header("Retry-After", "0")
+ .set_body_json(json!({"message":"still limited"})),
+ )
+ .expect(u64::from(MAX_RATE_LIMIT_RETRIES + 1))
+ .mount(&server)
+ .await;
+ let error = page_text(&mut paced(&server), "page").await.unwrap_err();
+ assert_eq!(
+ error.to_string(),
+ "notion blocks returned 429 Too Many Requests: still limited"
+ );
+}
+
+#[tokio::test]
+async fn child_failure_keeps_only_title_and_preserves_page_identity() {
+ let server = MockServer::start().await;
+ Mock::given(method("POST")).and(path("/search"))
+ .respond_with(ResponseTemplate::new(200).set_body_json(json!({
+ "results":[{"id":"page", "properties":{"Name":{"type":"title", "title":[{"plain_text":"Quarterly policy"}]}},
+ "last_edited_time":"2026-10-01T12:00:00Z"}], "has_more":false
+ }))).expect(1).mount(&server).await;
+ children(
+ &server,
+ "page",
+ None,
+ vec![block("child", "toggle", "Partial body", true)],
+ None,
+ )
+ .await;
+ Mock::given(path("/blocks/child/children"))
+ .respond_with(ResponseTemplate::new(500).set_body_json(json!({"message":"unavailable"})))
+ .expect(1)
+ .mount(&server)
+ .await;
+ let (pages, truncated) = fetch_pages(&mut paced(&server), None).await.unwrap();
+ assert!(!truncated);
+ assert_eq!(pages.len(), 1);
+ assert_eq!(pages[0].external_key, "notion://page");
+ assert_eq!(pages[0].filename, "Quarterly-policy.md");
+ assert_eq!(
+ pages[0].last_edited,
+ Some("2026-10-01T12:00:00Z".parse().unwrap())
+ );
+ assert_eq!(pages[0].text, "# Quarterly policy\n\n");
+}