mega 0.8.0

An API client library for interacting with MEGA
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

//!
//! Integration test for using events to update local nodes and chain operations.
//!

use std::env;

use rand::distributions::{Alphanumeric, DistString};

#[tokio::test]
async fn event_updates_test() {
    let email = env::var("MEGA_EMAIL").expect("missing MEGA_EMAIL environment variable");
    let password = env::var("MEGA_PASSWORD").expect("missing MEGA_PASSWORD environment variable");
    let mfa = env::var("MEGA_MFA").ok();

    let http_client = reqwest::Client::new();
    let mut mega = mega::Client::builder().build(http_client).unwrap();

    mega.login(&email, &password, mfa.as_deref())
        .await
        .expect("could not log in to MEGA");

    let mut nodes = mega
        .fetch_own_nodes()
        .await
        .expect("could not fetch own nodes");

    let root = nodes
        .get_node_by_path("/Root/mega-rs-tests")
        .expect("could not find Cloud Drive root");

    let cloud_drive_handle = root.handle().to_string();

    let uploaded = {
        let mut rng = rand::thread_rng();
        Alphanumeric.sample_string(&mut rng, 1024)
    };

    let file_name = {
        let mut rng = rand::thread_rng();
        format!(
            "mega-rs-test-file-{0}.txt",
            Alphanumeric.sample_string(&mut rng, 10),
        )
    };

    let size = uploaded.len();

    mega.upload_node(
        root,
        file_name.as_str(),
        size.try_into().unwrap(),
        uploaded.as_bytes(),
        mega::LastModified::Now,
    )
    .await
    .expect("could not upload test file");

    let uploaded_handle = loop {
        let batch = mega
            .wait_events(&nodes)
            .await
            .expect("could not fetch MEGA events");

        let maybe_uploaded_handle = batch.events().iter().find_map(|event| {
            let mega::Event::NodeCreated { nodes } = event else {
                return None;
            };

            nodes.iter().find_map(|node| {
                (node.parent() == Some(cloud_drive_handle.as_str()) && node.name() == file_name)
                    .then(|| node.handle().to_string())
            })
        });

        nodes
            .apply_events(batch)
            .expect("could not apply events to local nodes");

        if let Some(uploaded_handle) = maybe_uploaded_handle {
            break uploaded_handle;
        }
    };

    let node = nodes
        .get_node_by_handle(&uploaded_handle)
        .expect("could not find test file node after upload");

    let mut downloaded = Vec::default();
    mega.download_node(node, &mut downloaded)
        .await
        .expect("could not download test file");

    assert_eq!(uploaded.as_bytes(), downloaded.as_slice());

    let new_file_name = {
        let mut rng = rand::thread_rng();
        format!(
            "mega-rs-test-file-{0}.txt",
            Alphanumeric.sample_string(&mut rng, 10),
        )
    };

    mega.rename_node(node, &new_file_name)
        .await
        .expect("could not rename node");

    loop {
        let batch = mega
            .wait_events(&nodes)
            .await
            .expect("could not fetch MEGA events");

        let found_event = batch.events().iter().any(|event| {
            matches!(event, mega::Event::NodeUpdated { attrs } if attrs.handle() == uploaded_handle.as_str())
        });

        nodes
            .apply_events(batch)
            .expect("could not apply events to local nodes");

        if found_event {
            break;
        }
    }

    let node = nodes
        .get_node_by_handle(&uploaded_handle)
        .expect("could not find test file node after rename");

    mega.delete_node(node)
        .await
        .expect("could not delete test file");

    loop {
        let batch = mega
            .wait_events(&nodes)
            .await
            .expect("could not fetch MEGA events");

        let found_event = batch.events().iter().any(|event| {
            matches!(event, mega::Event::NodeDeleted { handle } if handle.as_str() == uploaded_handle.as_str())
        });

        nodes
            .apply_events(batch)
            .expect("could not apply events to local nodes");

        if found_event {
            break;
        }
    }

    mega.logout().await.expect("could not log out from MEGA");
}