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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

use activitystreams_vocabulary::{Iri, Name};

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

/// Tests database operations on [Team] records.
pub async fn test_team(db: &Db) -> Result<()> {
    let person_id = Iri::try_from("https://example.dev/test_team_member")?;
    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("team_member")?;

    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);

    let team_uuid = db.rand_uuid();
    let team_name = Name::try_from("test_team")?;
    let team_id = Iri::try_from(format!("https://example.dev/{team_name}"))?;

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

    let mut team_inbox = Inbox::new()
        .with_id(team_inbox_id)
        .with_actor(TableEntry::create(TableType::Person, team_uuid));

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

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

    let mut team_outbox = Outbox::new()
        .with_id(team_outbox_id)
        .with_actor(TableEntry::create(TableType::Person, team_uuid));

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

    let mut team = Team::new()
        .with_uuid(team_uuid)
        .with_id(team_id.clone())
        .with_name(team_name)
        .with_inbox(team_inbox_uuid)
        .with_outbox(team_outbox_uuid)
        .with_members([person_uuid]);

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

    assert_eq!(Team::get(db, &team_uuid).await?, team);

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

    let mut team_key = Key::new()
        .with_id(team_key_id)
        .with_key_type(KeyType::Ed25519)
        .with_key(team_key_data)
        .with_is_private(true)
        .with_actor(TableEntry::create(TableType::Person, team_uuid));

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

    assert!(!team_key_uuid.is_nil());

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

    assert_eq!(ret_key, team_key);

    team.set_key_ids([team_key_uuid]);

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

    assert_eq!(Team::get(db, &team_uuid).await?, team);

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

    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(())
}