anytype 0.5.0

An ergonomic Anytype API client in rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

// SPDX-FileCopyrightText: 2026 Steve Schoettler
// SPDX-License-Identifier: Apache-2.0

//! Live verification of space-description update semantics (any-e7ei).
//!
//! Proves, against a real server in a cleanup-owned disposable space, that an
//! update which omits the description leaves it untouched, that a string
//! replaces it, and that [`clear_description`] clears it — and that the
//! cleared description reads back as `Some("")`, the same representation a
//! never-described space reports.
//!
//! [`clear_description`]: anytype::spaces::UpdateSpaceRequest::clear_description

use std::sync::{
    Arc,
    atomic::{AtomicBool, Ordering},
};

use anytype::test_util::{
    DisposableRun, TestError, retry_definitive_rate_limit, with_disposable_space_context,
};

#[tokio::test]
#[ignore = "requires configured real server and disposable test admission"]
#[serial_test::serial(disposable_anytype_api)]
async fn space_description_omission_replacement_and_clearing_are_distinct() {
    let callback_ran = Arc::new(AtomicBool::new(false));
    let callback_flag = Arc::clone(&callback_ran);
    let outcome = Box::pin(with_disposable_space_context(
        "space-description-clearing",
        move |ctx| {
            callback_flag.store(true, Ordering::SeqCst);
            Box::pin(async move {
                // A freshly created space without a description reports "".
                let created = ctx.client.space(&ctx.space_id).get().await?;
                assert_eq!(created.description.as_deref(), Some(""));
                assert_eq!(created.description_text(), None);
                let name = created.name.clone();

                // Replacement: a string sets the description.
                let replaced = retry_definitive_rate_limit("space description set", || async {
                    ctx.client
                        .update_space(&ctx.space_id)
                        .description("initial description")
                        .no_verify()
                        .update()
                        .await
                })
                .await?;
                assert_eq!(replaced.description.as_deref(), Some("initial description"));
                assert_eq!(replaced.description_text(), Some("initial description"));

                // Omission: an update that does not mention the description
                // leaves it untouched (the name is re-sent unchanged so the
                // prefix-owned space keeps its cleanup identity).
                let renamed = retry_definitive_rate_limit("space name-only update", || async {
                    ctx.client
                        .update_space(&ctx.space_id)
                        .name(&name)
                        .no_verify()
                        .update()
                        .await
                })
                .await?;
                assert_eq!(renamed.description.as_deref(), Some("initial description"));
                let read_back = ctx.client.space(&ctx.space_id).get().await?;
                assert_eq!(
                    read_back.description.as_deref(),
                    Some("initial description")
                );

                // Clearing: the cleared description round-trips as "".
                let cleared = retry_definitive_rate_limit("space description clear", || async {
                    ctx.client
                        .update_space(&ctx.space_id)
                        .clear_description()
                        .no_verify()
                        .update()
                        .await
                })
                .await?;
                assert_eq!(cleared.description.as_deref(), Some(""));
                assert_eq!(cleared.description_text(), None);
                let read_back = ctx.client.space(&ctx.space_id).get().await?;
                assert_eq!(read_back.description.as_deref(), Some(""));
                if read_back.name != name {
                    return Err(TestError::Assertion {
                        message: "space name changed during description updates".to_owned(),
                    });
                }
                Ok(())
            })
        },
    ))
    .await
    .expect("cleanup-safe space description suite");

    match outcome {
        DisposableRun::Completed(()) => assert!(callback_ran.load(Ordering::SeqCst)),
        DisposableRun::Skipped(reason) => {
            assert!(!callback_ran.load(Ordering::SeqCst));
            eprintln!("space description suite skipped before callback: {reason:?}");
        }
    }
}