activityforge 0.1.0-pre-alpha

ActivityForge federated git forges over ActivityPub
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

use activitystreams_vocabulary::{Iri, Name};

use activityforge::db::actor::Person;
use activityforge::db::object::{Inbox, Key, Outbox};
use activityforge::db::{Db, KeyType, TableEntry, TableType};
use activityforge::{Error, Result};

/// Tests database operations on [Person] records.
pub async fn test_person(db: &Db) -> Result<()> {
    let person_id = Iri::try_from("https://example.dev/test_person")?;
    let person_uuid = db.rand_uuid();

    let person_inbox_id = Iri::try_from(format!("{person_id}/inbox"))?;

    let mut person_inbox = Inbox::new()
        .with_id(person_inbox_id)
        .with_actor(TableEntry::create(TableType::Person, person_uuid));

    let person_inbox_uuid = person_inbox
        .insert(db)
        .await
        .map_err(|err| Error::sql(format!("error inserting person inbox: {err}")))?;

    let person_outbox_id = Iri::try_from(format!("{person_id}/outbox"))?;

    let mut person_outbox = Outbox::new()
        .with_id(person_outbox_id)
        .with_actor(TableEntry::create(TableType::Person, person_uuid));

    let person_outbox_uuid = person_outbox
        .insert(db)
        .await
        .map_err(|err| Error::sql(format!("error inserting person outbox: {err}")))?;

    let person_name = Name::try_from("person")?;

    let mut person = Person::new()
        .with_uuid(person_uuid)
        .with_id(person_id.clone())
        .with_name(person_name)
        .with_inbox(person_inbox_uuid)
        .with_outbox(person_outbox_uuid);

    let person_uuid = person
        .insert(db)
        .await
        .map_err(|err| Error::sql(format!("error inserting person record: {err}")))?;

    let person_key_id = Iri::try_from(format!("{person_id}/keys#main-key"))?;
    let mut person_key_data = [0u8; 64];
    rand::fill(&mut person_key_data);

    let mut person_key = Key::new()
        .with_id(person_key_id)
        .with_key_type(KeyType::Ed25519)
        .with_key(person_key_data)
        .with_is_private(true)
        .with_actor(TableEntry::create(TableType::Person, person_uuid));

    let person_key_uuid = person_key
        .insert(db)
        .await
        .map_err(|err| Error::sql(format!("error inserting key record: {err}")))?;

    assert!(!person_key_uuid.is_nil());

    let ret_key = Key::get(db, &person_key_uuid)
        .await
        .map_err(|err| Error::sql(format!("error getting key record: {err}")))?;

    assert_eq!(ret_key, person_key);

    person.set_key_ids([person_key_uuid]);

    person
        .update(db)
        .await
        .map_err(|err| Error::sql(format!("error updating person record: {err}")))?;

    assert_eq!(Person::get(db, &person_uuid).await?, person);

    person
        .delete(db)
        .await
        .map_err(|err| Error::sql(format!("error deleting person record: {err}")))?;

    assert!(Person::get(db, &person_uuid).await.is_err());

    Ok(())
}