rusaint 0.16.3

Easy-to-use SSU u-saint client
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

use crate::{TARGET_SEMESTER, TARGET_YEAR, get_session};
use lazy_static::lazy_static;
use rusaint::RusaintError;
use rusaint::application::course_grades::{CourseGradesApplication, model::CourseType};
use rusaint::client::USaintClientBuilder;
use std::sync::{Arc, OnceLock};
use tokio::sync::{Mutex, RwLock};
use tracing_test::traced_test;

lazy_static! {
    static ref APP: Mutex<OnceLock<Arc<RwLock<CourseGradesApplication>>>> =
        Mutex::new(OnceLock::new());
}

async fn get_app() -> Result<Arc<RwLock<CourseGradesApplication>>, RusaintError> {
    let app_lock = APP.lock().await;
    if let Some(lock) = app_lock.get() {
        Ok(lock.clone())
    } else {
        let session = get_session().await.unwrap().clone();
        app_lock
            .set(Arc::new(RwLock::new(
                USaintClientBuilder::new()
                    .session(session)
                    .build_into()
                    .await?,
            )))
            .unwrap();
        Ok(app_lock.get().unwrap().clone())
    }
}

#[tokio::test]
#[traced_test]
async fn recorded_summary() {
    let lock = get_app().await.unwrap();
    let mut app = lock.write().await;
    let recorded_summary = app.recorded_summary(CourseType::Bachelor).await.unwrap();
    tracing::info!("Recorded: {:?}", recorded_summary);
    let certificated_summary = app
        .certificated_summary(CourseType::Bachelor)
        .await
        .unwrap();
    tracing::info!("Certificated: {:?}", certificated_summary);
}

#[tokio::test]
#[traced_test]
async fn certificated_summary() {
    let lock = get_app().await.unwrap();
    let mut app = lock.write().await;
    let certificated_summary = app
        .certificated_summary(CourseType::Bachelor)
        .await
        .unwrap();
    tracing::info!("Certificated: {:?}", certificated_summary);
}

#[tokio::test]
#[traced_test]
async fn semesters() {
    let lock = get_app().await.unwrap();
    let mut app = lock.write().await;
    let semesters = app.semesters(CourseType::Bachelor).await.unwrap();
    tracing::info!("{:?}", semesters);
    assert!(!semesters.is_empty());
}

#[tokio::test]
#[traced_test]
async fn classes_with_detail() {
    let lock = get_app().await.unwrap();
    let mut app = lock.write().await;
    let details = app
        .classes(CourseType::Bachelor, *TARGET_YEAR, *TARGET_SEMESTER, true)
        .await
        .unwrap();
    tracing::info!("{:?}", details);
    assert!(!details.is_empty());
    tracing::info!("Try to obtain class's detail");
    let detail_code = details.iter().find(|grade| grade.detail().is_some());
    if detail_code.is_none() {
        tracing::info!("No class found with detail");
        return;
    }
    let detail_code = detail_code.unwrap();
    let detail = app
        .class_detail(
            CourseType::Bachelor,
            *TARGET_YEAR,
            *TARGET_SEMESTER,
            detail_code.code(),
        )
        .await
        .unwrap();
    tracing::info!("{:?}", detail);
    assert!(!detail.is_empty());
}

#[tokio::test]
#[traced_test]
async fn grades_by_classification() {
    let lock = get_app().await.unwrap();
    let mut app = lock.write().await;
    let result = app
        .grades_by_classification(CourseType::Bachelor)
        .await
        .unwrap();
    tracing::info!("{:?}", result);
    assert!(!result.grades().is_empty());
}