misskey_api/streaming/channel/
drive.rs

1use crate::model::{
2    drive::{DriveFile, DriveFolder},
3    id::Id,
4};
5use crate::streaming::channel::NoOutgoing;
6
7use serde::{Deserialize, Serialize};
8
9#[derive(Deserialize, Debug, Clone)]
10#[serde(rename_all = "camelCase", tag = "type", content = "body")]
11pub enum DriveStreamEvent {
12    FolderCreated(DriveFolder),
13    FolderUpdated(DriveFolder),
14    FolderDeleted(Id<DriveFolder>),
15    FileCreated(DriveFile),
16    FileUpdated(DriveFile),
17    FileDeleted(Id<DriveFile>),
18}
19
20#[derive(Serialize, Default, Debug, Clone)]
21pub struct Request {}
22
23impl misskey_core::streaming::ConnectChannelRequest for Request {
24    type Incoming = DriveStreamEvent;
25    type Outgoing = NoOutgoing;
26
27    const NAME: &'static str = "drive";
28}
29
30#[cfg(test)]
31mod tests {
32    use super::{DriveStreamEvent, Request};
33    use crate::test::{websocket::TestClient, ClientExt};
34
35    use futures::{future, StreamExt};
36
37    #[tokio::test]
38    async fn subscribe_unsubscribe() {
39        let client = TestClient::new().await;
40        let mut stream = client.channel(Request::default()).await.unwrap();
41        stream.disconnect().await.unwrap();
42    }
43
44    #[tokio::test]
45    async fn stream_folder_created() {
46        let client = TestClient::new().await;
47        let mut stream = client.channel(Request::default()).await.unwrap();
48
49        future::join(
50            client.test(crate::endpoint::drive::folders::create::Request::default()),
51            async {
52                loop {
53                    match stream.next().await.unwrap().unwrap() {
54                        DriveStreamEvent::FolderCreated(_) => break,
55                        _ => continue,
56                    }
57                }
58            },
59        )
60        .await;
61    }
62
63    #[tokio::test]
64    async fn stream_folder_updated() {
65        let client = TestClient::new().await;
66        let folder = client
67            .test(crate::endpoint::drive::folders::create::Request::default())
68            .await;
69        let mut stream = client.channel(Request::default()).await.unwrap();
70
71        future::join(
72            client.test(crate::endpoint::drive::folders::update::Request {
73                folder_id: folder.id,
74                name: Some("test".to_string()),
75                parent_id: None,
76            }),
77            async {
78                loop {
79                    match stream.next().await.unwrap().unwrap() {
80                        DriveStreamEvent::FolderUpdated(_) => break,
81                        _ => continue,
82                    }
83                }
84            },
85        )
86        .await;
87    }
88
89    #[tokio::test]
90    async fn stream_folder_deleted() {
91        let client = TestClient::new().await;
92        let folder = client
93            .test(crate::endpoint::drive::folders::create::Request::default())
94            .await;
95        let mut stream = client.channel(Request::default()).await.unwrap();
96
97        future::join(
98            client.test(crate::endpoint::drive::folders::delete::Request {
99                folder_id: folder.id,
100            }),
101            async {
102                loop {
103                    match stream.next().await.unwrap().unwrap() {
104                        DriveStreamEvent::FolderDeleted(_) => break,
105                        _ => continue,
106                    }
107                }
108            },
109        )
110        .await;
111    }
112
113    #[tokio::test]
114    async fn stream_file_created() {
115        let client = TestClient::new().await;
116        let url = client.avatar_url().await;
117        let mut stream = client.channel(Request::default()).await.unwrap();
118
119        future::join(client.upload_from_url(url), async {
120            loop {
121                match stream.next().await.unwrap().unwrap() {
122                    DriveStreamEvent::FileCreated(_) => break,
123                    _ => continue,
124                }
125            }
126        })
127        .await;
128    }
129
130    #[tokio::test]
131    async fn stream_file_updated() {
132        let client = TestClient::new().await;
133        let url = client.avatar_url().await;
134        let file = client.upload_from_url(url).await;
135        let mut stream = client.channel(Request::default()).await.unwrap();
136
137        future::join(
138            client.test(crate::endpoint::drive::files::update::Request {
139                file_id: file.id,
140                folder_id: None,
141                is_sensitive: None,
142                name: Some("test".to_string()),
143            }),
144            async {
145                loop {
146                    match stream.next().await.unwrap().unwrap() {
147                        DriveStreamEvent::FileUpdated(_) => break,
148                        _ => continue,
149                    }
150                }
151            },
152        )
153        .await;
154    }
155
156    #[tokio::test]
157    async fn stream_file_deleted() {
158        let client = TestClient::new().await;
159        let url = client.avatar_url().await;
160        let file = client.upload_from_url(url).await;
161        let mut stream = client.channel(Request::default()).await.unwrap();
162
163        future::join(
164            client.test(crate::endpoint::drive::files::delete::Request { file_id: file.id }),
165            async {
166                loop {
167                    match stream.next().await.unwrap().unwrap() {
168                        DriveStreamEvent::FileDeleted(_) => break,
169                        _ => continue,
170                    }
171                }
172            },
173        )
174        .await;
175    }
176}
misskey_api/streaming/channel/drive.rs

misskey_api/streaming/channel/
drive.rs
