Skip to content

World's first open-source enterprise world model.

14.0 KB
Raw Blame
//! 改区间的路由收发的是存的边界(#994):`end_after_period` 是唯一一个缺省即保留的字段。
//!
//! 实体详情读得到标记;不带它的请求,终点(时刻与精度)没动、起点还在就留着,改了终点或清掉
//! 起点就丢掉(时刻照旧);显式的值照收,只改标记也算改了终点;显式 true 得是状态属性、有起点、
//! 终点有日期;倒置按截到精度之后的两端判。每一步的结果收进一张表一起比,dev 上哪几步不同一次
//! 看全。没有 `UTOPIA_DATABASE_URL` 时跳过。
use axum::body::{to_bytes, Body};
use axum::http::{Request, StatusCode};
use axum::Router;
use chrono::{DateTime, Utc};
use serde_json::{json, Value};
use std::sync::Arc;
use tower::ServiceExt;
use uuid::Uuid;

const MARCH: &str = "2024-03-01T00:00:00Z";
const FEB: &str = "2024-02-01T00:00:00Z";
const END: &str = "2025-01-01T00:00:00Z";
const LATER: &str = "2026-01-01T00:00:00Z";

async fn send(
    app: &Router,
    token: &str,
    method: &str,
    uri: String,
    body: &Value,
) -> anyhow::Result<(StatusCode, Value)> {
    let response = app
        .clone()
        .oneshot(
            Request::builder()
                .method(method)
                .uri(uri)
                .header("content-type", "application/json")
                .header("authorization", format!("Bearer {token}"))
                .body(Body::from(body.to_string()))?,
        )
        .await?;
    let status = response.status();
    let bytes = to_bytes(response.into_body(), usize::MAX).await?;
    Ok((status, serde_json::from_slice(&bytes)?))
}

/// 一个请求体:起点日精度、终点年精度,空串是没有;标记给了才带
fn span(from: &str, to: &str, mark: Option<bool>) -> Value {
    let from = Some(from).filter(|t| !t.is_empty());
    let to = Some(to).filter(|t| !t.is_empty());
    let mut body = json!({
        "valid_from": from, "valid_from_precision": from.map(|_| "day"),
        "valid_to": to, "valid_to_precision": to.map(|_| "year"),
    });
    if let Some(mark) = mark {
        body["end_after_period"] = json!(mark);
    }
    body
}

#[tokio::test]
async fn a_correction_keeps_the_mark_unless_the_request_changes_it() -> anyhow::Result<()> {
    let Some(url) = utopia_store::test_db::url() else {
        return Ok(());
    };
    let pool = sqlx::PgPool::connect(&url).await?;
    utopia_store::db::migrate(&pool).await?;
    let [org, ws, kb, editor, works_for, lin, meridian, marked, loose] =
        std::array::from_fn(|_| Uuid::now_v7());
    // Only locally generated UUIDs and the constants above are interpolated into fixture SQL.
    sqlx::raw_sql(&format!(
        "INSERT INTO organizations(id,name) VALUES ('{org}','fact-time-route');
         INSERT INTO workspaces(id,org_id,name) VALUES ('{ws}','{org}','fact-time-route');
         INSERT INTO users(id,org_id,email,display_name,password_hash)
              VALUES ('{editor}','{org}','{editor}@time.test','editor','unused');
         INSERT INTO knowledge_bases(id,workspace_id,name) VALUES ('{kb}','{ws}','times');
         INSERT INTO kb_members(kb_id,user_id,role) VALUES ('{kb}','{editor}','editor');
         INSERT INTO relation_types(id,kb_id,key,label,temporal)
              VALUES ('{works_for}','{kb}','works_for','works for','state');
         INSERT INTO entities(id,kb_id,canonical_name)
              VALUES ('{lin}','{kb}','Lin Zhao'), ('{meridian}','{kb}','Meridian Systems');
         -- 「left in 2024」关上的一行,记着说的是 2024;同样的区间、没有谓词的一行
         INSERT INTO facts(id,kb_id,subject_id,predicate_id,object_id,layer,confidence,
                           valid_from,valid_from_precision,valid_to,valid_to_precision,
                           end_after_period) VALUES
             ('{marked}','{kb}','{lin}','{works_for}','{meridian}','typed',0.9,
              '{MARCH}','day','{END}','year',TRUE),
             ('{loose}','{kb}','{lin}',NULL,'{meridian}','typed',0.9,
              '{MARCH}','day','{END}','year',FALSE);"
    ))
    .execute(&pool)
    .await?;
    let result = async {
        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 token = crate::auth::issue_token(&state, editor)?;
        let app = crate::api::router(state, &config);

        let detail = format!("/api/v1/kbs/{kb}/entities/{lin}");
        let (_, detail) = send(&app, &token, "GET", detail, &Value::Null).await?;
        let mut read = detail["facts"].as_array().into_iter().flatten();
        let read = read.find(|x| x["id"] == json!(marked));
        let mut seen = vec![("entity detail", json!(read.map(|x| &x["end_after_period"])))];
        let mut wanted = vec![("entity detail", json!(true))];
        // 每一步:改哪一行(None 是上一步写下的那行)、请求体、要的结果——写下的那一行(标记、
        // 人改过哪一端、终点),或拒绝的代码。不带标记的:只改起点留着,改了终点的时刻或精度、
        // 清掉起点都丢掉;显式的照收,只改标记把终点那一端记成人改的;显式 true 缺起点、缺终点、
        // 不是状态的都不收
        let bad = json!([422, "bad_end_after_period"]);
        let steps = [
            ("start only", None, span(FEB, END, None), json!([true, "start", END])),
            ("mark false", None, span(FEB, END, Some(false)), json!([false, "both", END])),
            ("mark true", None, span(FEB, END, Some(true)), json!([true, "both", END])),
            ("new end", None, span(FEB, LATER, None), json!([false, "both", LATER])),
            ("mark true again", None, span(FEB, END, Some(true)), json!([true, "both", END])),
            (
                "precision only",
                None,
                json!({"valid_from": FEB, "valid_from_precision": "day",
                       "valid_to": END, "valid_to_precision": "month"}),
                json!([false, "both", END]),
            ),
            ("marked once more", None, span(FEB, END, Some(true)), json!([true, "both", END])),
            ("start cleared", None, span("", END, None), json!([false, "both", END])),
            ("true, no start", None, span("", END, Some(true)), bad.clone()),
            ("true, no end", None, span(FEB, "", Some(true)), bad.clone()),
            ("true, no state", Some(loose), span(MARCH, END, Some(true)), bad),
            // 小时精度的 08:30 是 08:00,早于分钟精度的起点 08:10
            (
                "inverted once truncated",
                Some(loose),
                json!({"valid_from": "2026-06-01T08:10:00Z", "valid_from_precision": "minute",
                       "valid_to": "2026-06-01T08:30:00Z", "valid_to_precision": "hour"}),
                json!([422, "interval_inverted"]),
            ),
        ];
        let mut fact = marked;
        for (label, target, body, want) in steps {
            let uri = format!("/api/v1/kbs/{kb}/facts/{}", target.unwrap_or(fact));
            let (status, reply) = send(&app, &token, "PATCH", uri, &body).await?;
            let got = match reply["fact_id"].as_str() {
                Some(id) => {
                    fact = id.parse()?;
                    let row: (bool, Option<String>, Option<DateTime<Utc>>) = sqlx::query_as(
                        "SELECT end_after_period, corrected_ends, valid_to FROM facts WHERE id = $1",
                    )
                    .bind(fact)
                    .fetch_one(&pool)
                    .await?;
                    json!(row)
                }
                None => json!([status.as_u16(), reply["code"]]),
            };
            seen.push((label, got));
            wanted.push((label, want));
        }
        assert_eq!(seen, wanted);
        anyhow::Ok(())
    }
    .await;
    sqlx::query("DELETE FROM organizations WHERE id = $1")
        .bind(org)
        .execute(&pool)
        .await?;
    result
}

#[tokio::test]
async fn review_closes_refuse_inverted_intervals_without_settling_the_item() -> anyhow::Result<()> {
    let Some(url) = utopia_store::test_db::url() else {
        return Ok(());
    };
    let pool = sqlx::PgPool::connect(&url).await?;
    let [org, ws, kb, editor, property, lin, meridian, orion, old, new, conflict, violation] =
        std::array::from_fn(|_| Uuid::now_v7());
    // Only locally generated UUIDs and fixed timestamps enter this fixture SQL.
    sqlx::raw_sql(&format!(
        "INSERT INTO organizations(id,name) VALUES ('{org}','review-close-time');
         INSERT INTO workspaces(id,org_id,name) VALUES ('{ws}','{org}','review-close-time');
         INSERT INTO users(id,org_id,email,display_name,password_hash)
              VALUES ('{editor}','{org}','{editor}@time.test','editor','unused');
         INSERT INTO knowledge_bases(id,workspace_id,name) VALUES ('{kb}','{ws}','times');
         INSERT INTO kb_members(kb_id,user_id,role) VALUES ('{kb}','{editor}','editor');
         INSERT INTO relation_types(id,kb_id,key,label,temporal)
              VALUES ('{property}','{kb}','works_for','works for','state');
         INSERT INTO entities(id,kb_id,canonical_name) VALUES
              ('{lin}','{kb}','Lin Zhao'), ('{meridian}','{kb}','Meridian'), ('{orion}','{kb}','Orion');
         INSERT INTO facts(id,kb_id,subject_id,predicate_id,object_id,confidence,
                           valid_from,valid_from_precision) VALUES
              ('{old}','{kb}','{lin}','{property}','{meridian}',0.9,'{MARCH}','day'),
              ('{new}','{kb}','{lin}','{property}','{orion}',0.9,NULL,NULL);
         INSERT INTO fact_conflicts(id,kb_id,old_fact_id,new_fact_id,reason)
              VALUES ('{conflict}','{kb}','{old}','{new}','no_time');
         INSERT INTO axiom_violations(id,kb_id,kind,left_fact,right_fact)
              VALUES ('{violation}','{kb}','derived_contradiction','{old}','{new}');"
    ))
    .execute(&pool)
    .await?;
    let result = async {
        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 token = crate::auth::issue_token(&state, editor)?;
        let app = crate::api::router(state, &config);
        let prefix = format!("/api/v1/kbs/{kb}");
        // The first date is later as written, but earlier at year precision.
        // The existing equal-state refusal must reach all three cards as well.
        for (at, precision, code) in [
            ("2024-10-01T00:00:00Z", "year", "interval_inverted"),
            (MARCH, "month", "empty_state_span"),
        ] {
            for (path, body) in [
                (
                    format!("facts/{old}/close"),
                    json!({"valid_to": at, "valid_to_precision": precision}),
                ),
                (
                    format!("conflicts/{conflict}"),
                    json!({"action": "close", "close_at": at, "close_at_precision": precision}),
                ),
                (
                    format!("review/violations/{violation}"),
                    json!({"resolution": "fact_closed", "close_at": at, "close_at_precision": precision}),
                ),
            ] {
                let (status, reply) = send(&app, &token, "POST", format!("{prefix}/{path}"), &body).await?;
                assert_eq!((status, reply["code"].as_str()), (StatusCode::UNPROCESSABLE_ENTITY, Some(code)), "{path}: {reply}");
            }
        }
        // A conflict with no explicit date closes at the new row's start; it must
        // get the same store guard, even though no date came through the route.
        sqlx::query("UPDATE facts SET valid_from = '2024-01-01', valid_from_precision = 'year' WHERE id = $1")
            .bind(new).execute(&pool).await?;
        let (status, reply) = send(&app, &token, "POST", format!("{prefix}/conflicts/{conflict}"), &json!({"action": "close"})).await?;
        assert_eq!((status, reply["code"].as_str()), (StatusCode::UNPROCESSABLE_ENTITY, Some("interval_inverted")));
        let unchanged: bool = sqlx::query_scalar(
            "SELECT (SELECT count(*) = 2 FROM facts WHERE kb_id = $1)
                AND EXISTS (SELECT 1 FROM facts WHERE id = $2 AND invalidated_at IS NULL AND valid_to IS NULL)
                AND EXISTS (SELECT 1 FROM fact_conflicts WHERE id = $3 AND status = 'open' AND resolution IS NULL)
                AND EXISTS (SELECT 1 FROM axiom_violations WHERE id = $4 AND status = 'open' AND resolution IS NULL)",
        ).bind(kb).bind(old).bind(conflict).bind(violation).fetch_one(&pool).await?;
        assert!(unchanged, "refused closes write no replacement and leave both queues open");

        // A later date can still close the refused row, with the endpoint stored
        // at its supplied precision, without translating it to a period's end.
        let (status, _) = send(&app, &token, "POST", format!("{prefix}/facts/{old}/close"),
            &json!({"valid_to": "2024-09-19T00:00:00Z", "valid_to_precision": "month"})).await?;
        assert_eq!(status, StatusCode::OK);
        let closed: (DateTime<Utc>, String, bool) = sqlx::query_as(
            "SELECT valid_to, valid_to_precision, end_after_period FROM facts WHERE supersedes = $1",
        ).bind(old).fetch_one(&pool).await?;
        assert_eq!(closed, ("2024-09-01T00:00:00Z".parse()?, "month".into(), false));
        anyhow::Ok(())
    }.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
}