dialtone_sqlx 0.1.0

Dialtone SQLx Back-End
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

use dialtone_common::rest::ap_objects::ap_object_reference::ApObjectReferenceType;
use dialtone_sqlx::db::ap_object::page_by_reference::page_ap_objects_by_reference;
use dialtone_sqlx::db::ap_object_reference::insert::insert_ap_object_reference;
use dialtone_test_util::create_actor::create_actor_tst_utl;
use dialtone_test_util::create_ap_object::create_article_tst_utl;
use dialtone_test_util::create_site::create_site_tst_utl;
use dialtone_test_util::{test_action, test_pg};
use sqlx::{Pool, Postgres};

#[tokio::test]
async fn page_all_ap_objects_by_reference_test() {
    test_pg::test_pg(move |pool| async move {
        let host_name = "example.net";
        create_site_tst_utl(&pool, host_name).await;
        let created_actor = create_actor_tst_utl(&pool, "testymctestfase", host_name).await;
        create_many_articles(
            &pool,
            host_name,
            created_actor.owned_actor.ap.preferred_user_name.as_str(),
            20,
            "test_liked_article",
            &ApObjectReferenceType::Like,
        )
        .await;

        let page1_result = page_ap_objects_by_reference(
            &pool,
            None,
            None,
            5,
            created_actor.owned_actor.ap.id.as_str(),
            &ApObjectReferenceType::Like,
        )
        .await;
        test_action!(page1_result);
        let page1_ap_objects = page1_result.unwrap().unwrap();
        println!("{:?}", page1_ap_objects);
        assert_eq!(page1_ap_objects.page_values.len(), 5);

        let page2_result = page_ap_objects_by_reference(
            &pool,
            None,
            Some(&page1_ap_objects.max_modified_at),
            10,
            created_actor.owned_actor.ap.id.as_str(),
            &ApObjectReferenceType::Like,
        )
        .await;
        test_action!(page2_result);
        let page2_ap_objects = page2_result.unwrap().unwrap();
        assert_eq!(page2_ap_objects.page_values.len(), 10);

        let all_page_result = page_ap_objects_by_reference(
            &pool,
            None,
            None,
            20,
            created_actor.owned_actor.ap.id.as_str(),
            &ApObjectReferenceType::Like,
        )
        .await;
        test_action!(all_page_result);
        let all_page_ap_objects = all_page_result.unwrap().unwrap();
        assert_eq!(all_page_ap_objects.page_values.len(), 20);
    })
    .await;
}

#[tokio::test]
async fn page_ap_objects_of_reference_test() {
    test_pg::test_pg(move |pool| async move {
        let host_name = "example.net";
        create_site_tst_utl(&pool, host_name).await;
        let actor1 = create_actor_tst_utl(&pool, "testymctestfase", host_name).await;
        create_many_articles(
            &pool,
            host_name,
            actor1.owned_actor.ap.preferred_user_name.as_str(),
            20,
            "test_liked_article",
            &ApObjectReferenceType::Like,
        )
        .await;
        create_many_articles(
            &pool,
            host_name,
            actor1.owned_actor.ap.preferred_user_name.as_str(),
            30,
            "test_flagged_article",
            &ApObjectReferenceType::Flag,
        )
        .await;

        let liked_all_result = page_ap_objects_by_reference(
            &pool,
            None,
            None,
            20,
            actor1.owned_actor.ap.id.as_str(),
            &ApObjectReferenceType::Like,
        )
        .await;
        test_action!(liked_all_result);
        let liked_all_ap_objects = liked_all_result.unwrap().unwrap();
        assert_eq!(liked_all_ap_objects.page_values.len(), 20);

        let flagged_all_result = page_ap_objects_by_reference(
            &pool,
            None,
            None,
            30,
            actor1.owned_actor.ap.id.as_str(),
            &ApObjectReferenceType::Flag,
        )
        .await;
        test_action!(flagged_all_result);
        let flagged_all_ap_objects = flagged_all_result.unwrap().unwrap();
        assert_eq!(flagged_all_ap_objects.page_values.len(), 30);
    })
    .await;
}

async fn create_many_articles(
    pool: &Pool<Postgres>,
    host_name: &str,
    pun: &str,
    num_articles: i32,
    title_preamble: &str,
    reference_type: &ApObjectReferenceType,
) {
    for n in 1..=num_articles {
        let title = format!("{}_{}", title_preamble, n);
        let ap_object = create_article_tst_utl(pool, host_name, &title, Some(pun)).await;
        insert_ap_object_reference(
            pool,
            &ap_object.attributed_to.unwrap(),
            &ap_object.id.unwrap(),
            reference_type,
        )
        .await
        .unwrap();
    }
}