google-reader 0.0.2

A Rust library for interacting with Google Reader
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

//! Test things
//!

use std::env;

use anyhow::Context;
use log::*;

static LOG_LEVEL: &str = "DEBUG";

macro_rules!  setup_testing{
    () => {
        if let Err(_) = flexi_logger::Logger::try_with_str(LOG_LEVEL)
        .unwrap()
        .start()
    {};

    if env::var("CI").is_ok() {
        info!("Skipping test because we're in CI");
        return;
    }

    };
}

#[tokio::test]
async fn test_unread_count() {
    setup_testing!();

    let username =
        env::var("GOOGLE_READER_USERNAME").expect("Missing env var: GOOGLE_READER_USERNAME");
    let password =
        env::var("GOOGLE_READER_PASSWORD").expect("Missing env var: GOOGLE_READER_PASSWORD");
    let server = env::var("GOOGLE_READER_SERVER").expect("Missing env var: GOOGLE_READER_SERVER");

    let mut reader = super::GoogleReader::try_new(username, password, &server)
        .expect("Failed to create API object");

    let res = reader.unread_count().await;
    info!("{:?}", res);
    if server.contains("api/greader.php") {
        assert!(res.is_err());
    } else {
        assert!(res.is_ok());
    }
}

#[tokio::test]
async fn test_get_write_token() {
    setup_testing!();

    let username =
        env::var("GOOGLE_READER_USERNAME").expect("Missing env var: GOOGLE_READER_USERNAME");
    let password =
        env::var("GOOGLE_READER_PASSWORD").expect("Missing env var: GOOGLE_READER_PASSWORD");
    let server = env::var("GOOGLE_READER_SERVER").expect("Missing env var: GOOGLE_READER_SERVER");

    let mut reader = super::GoogleReader::try_new(username, password, server)
        .expect("Failed to create API object");

    let write_token = reader
        .get_write_token()
        .await
        .with_context(|| "Failed to get write_token")
        .unwrap();

    info!("Write token: {:?}", write_token);

    // let unread_ids = reader.get_unread_items().await.with_context(|| "Failed to query unread ids").unwrap();

    // for item in unread_ids {
    //     let unread = reader.get_item(item).await;
    //     info!("Unread ID: {:?}", unread);
    // }
}
#[tokio::test]
async fn test_get_unread_items() {
    setup_testing!();

    let username =
        env::var("GOOGLE_READER_USERNAME").expect("Missing env var: GOOGLE_READER_USERNAME");
    let password =
        env::var("GOOGLE_READER_PASSWORD").expect("Missing env var: GOOGLE_READER_PASSWORD");
    let server = env::var("GOOGLE_READER_SERVER").expect("Missing env var: GOOGLE_READER_SERVER");

    let mut reader = super::GoogleReader::try_new(username, password, server)
        .expect("Failed to create API object");

    let unread_response = reader
        .get_unread_items(None)
        .await
        .with_context(|| "Failed to query unread ids")
        .unwrap();

    unread_response.items.iter().for_each(|item| {
        info!("Unread: {:?}", item);
    });

    info!("Got {} items", unread_response.items.len());

    match unread_response.continuation {
        Some(_) => info!("Got continuation response, need to query again!"),
        None => info!("No continuation response, we're done!"),
    }
}

#[tokio::test]
async fn test_mark_item_read() {
    setup_testing!();
    let username =
        env::var("GOOGLE_READER_USERNAME").expect("Missing env var: GOOGLE_READER_USERNAME");
    let password =
        env::var("GOOGLE_READER_PASSWORD").expect("Missing env var: GOOGLE_READER_PASSWORD");
    let server = env::var("GOOGLE_READER_SERVER").expect("Missing env var: GOOGLE_READER_SERVER");

    let mut reader = super::GoogleReader::try_new(username, password, server)
        .expect("Failed to create API object");

    let unread = reader.get_unread_items(None).await.unwrap();

    if unread.items.is_empty() {
        error!("Can't test this because you don't have any unread items!");
        return;
    }

    for item in unread.items {
        println!("{} - {}", item.id, item.title);
        if item.title.contains("[Sponsor]") {
            let response = reader
                .mark_item_read(&item.id)
                .await
                .with_context(|| "Failed to mark item read")
                .unwrap();
            info!("Response from mark read: {:?}", response)
        }
    }
}