Skip to main content

datasources_memory/
lib.rs

1mod command;
2mod connection;
3mod driver;
4mod filter;
5mod store;
6mod transaction;
7
8pub use driver::MemoryDriver;
9
10#[cfg(test)]
11fn env_lock() -> std::sync::MutexGuard<'static, ()> {
12    static LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
13    LOCK.lock().unwrap_or_else(|error| error.into_inner())
14}
15
16#[cfg(test)]
17mod tests {
18    use super::*;
19    use crate::command::MemoryCommand;
20    use crate::connection::MemoryConnection;
21    use crate::filter::{json_to_value, matches, parse_filter};
22    use crate::store::{MemoryData, MemoryStore};
23    use futures_util::TryStreamExt;
24    use datasources::{
25        Row, create, default, register, reset, CRUDRepository, CRUDRepositoryOptions,
26        Command, Connection, DatasourceError,
27        InsertStatement, IsolationLevel, Parameter, SelectInsertedIdStatement, Value,
28        WhereText,
29    };
30    use serde_json::Value as JsonValue;
31    use std::collections::HashMap;
32    use std::sync::Arc;
33
34    fn crud(conn: Arc<MemoryConnection>) -> CRUDRepository {
35        let mut options = CRUDRepositoryOptions::default();
36        options.ids = vec![];
37        CRUDRepository::<Row>::new(conn, options).expect("repo")
38    }
39
40    fn clear_env() {
41        reset();
42        for key in ["INSTALLED_PROVIDERS", "DATASOURCE_URL", "PROVIDER"] {
43            std::env::remove_var(key);
44        }
45        register("memory", Arc::new(MemoryDriver));
46        std::env::set_var("PROVIDER", "memory");
47    }
48
49    fn rec(id: i64, name: &str) -> Row {
50        let mut r = Row::new();
51        r.insert("id".into(), Value::Int(id));
52        r.insert("name".into(), Value::from(name));
53        r
54    }
55
56    #[test]
57    fn register_and_create() {
58        let _guard = super::env_lock();
59        reset();
60        register("memory", Arc::new(MemoryDriver));
61        let ds = create(Some(&HashMap::from([("PROVIDER".into(), "memory".into())]))).unwrap();
62        assert_eq!(ds.provider(), "memory");
63    }
64
65    #[tokio::test]
66    async fn open_and_close() {
67        let connection = MemoryConnection::from_options(None);
68        connection.open().await.unwrap();
69        connection.close().await.unwrap();
70        assert_eq!(connection.is_open(), false);
71    }
72
73    #[tokio::test]
74    async fn open_twice_throws() {
75        let connection = MemoryConnection::from_options(None);
76        connection.open().await.unwrap();
77        assert_eq!(
78            connection.open().await.unwrap_err(),
79            DatasourceError::message("Connection is already open")
80        );
81    }
82
83    #[tokio::test]
84    async fn create_and_run_a_command() {
85        let connection = MemoryConnection::from_options(None);
86        connection.open().await.unwrap();
87        let command = connection.create_command();
88        let response = command.execute("insert", None).await.unwrap();
89        assert_eq!(response.rows_affected, 1);
90    }
91
92    #[tokio::test]
93    async fn start_a_transaction() {
94        let connection = MemoryConnection::from_options(None);
95        connection.open().await.unwrap();
96        let txn = connection.start_transaction(None).await.unwrap();
97        assert_eq!(txn.isolation(), IsolationLevel::ReadCommitted);
98    }
99
100    #[tokio::test]
101    async fn commit() {
102        let connection = MemoryConnection::from_options(None);
103        connection.open().await.unwrap();
104        let txn = connection.start_transaction(None).await.unwrap();
105        txn.commit().await.unwrap();
106        assert_eq!(txn.isolation(), IsolationLevel::ReadCommitted);
107    }
108
109    #[tokio::test]
110    async fn abort() {
111        let connection = MemoryConnection::from_options(None);
112        connection.open().await.unwrap();
113        let txn = connection.start_transaction(None).await.unwrap();
114        txn.abort().await.unwrap();
115        assert_eq!(txn.isolation(), IsolationLevel::ReadCommitted);
116    }
117
118    #[tokio::test]
119    async fn command_running_in_one_atomic_transaction() {
120        let _guard = super::env_lock();
121        clear_env();
122        let ds = default().unwrap();
123        let connection = ds.create_connection().await.unwrap();
124        connection.open().await.unwrap();
125        let txn = connection.start_transaction(None).await.unwrap();
126        let command = connection.create_command();
127        let fields = vec![Parameter::new("name", "ada")];
128        command
129            .execute_statement(&InsertStatement::new("people", &fields), Some(&fields))
130            .await
131            .unwrap();
132        let reader = command
133            .execute_reader_statement(&SelectInsertedIdStatement::new("people", "id"), None)
134            .await
135            .unwrap();
136        let moved = reader.next().await.unwrap();
137        let id = reader.current();
138        txn.commit().await.unwrap();
139        assert_eq!(moved, true);
140        assert_eq!(
141            id.as_ref().and_then(|row| row.get("id")),
142            Some(&Value::Int(1))
143        );
144    }
145
146    #[tokio::test]
147    async fn memory_crud_and_transactions() {
148        let _guard = super::env_lock();
149        let store = Arc::new(MemoryStore::new());
150        store.seed(&MemoryData::Rows(vec![rec(1, "a")]), "");
151        store.seed(&MemoryData::Rows(vec![rec(2, "b")]), "");
152        let mut named = HashMap::new();
153        named.insert("users".into(), vec![rec(3, "c")]);
154        named.insert("posts".into(), vec![rec(4, "d")]);
155        store.seed(&MemoryData::Collections(named.clone()), "");
156        store.seed(&MemoryData::Collections(named), "");
157        assert_eq!(store.collection("", |items| items.len()), 1);
158        assert_eq!(
159            store.collection("users", |items| items[0]["id"].clone()),
160            Value::Int(3)
161        );
162
163        let conn = Arc::new(MemoryConnection::new(
164            store.clone(),
165            "",
166            Some(MemoryData::Rows(vec![rec(8, "x")])),
167        ));
168        conn.open().await.unwrap();
169        assert_eq!(conn.collection_name(), "");
170        let repo = crud(conn.clone());
171        assert!(repo.read_single(&()).await.unwrap().is_some());
172        assert!(repo
173            .read_single(&WhereText::new("{\"id\":9}"))
174            .await
175            .unwrap()
176            .is_none());
177        assert!(!repo
178            .read(&WhereText::new("{\"id\":1}"))
179            .try_collect::<Vec<_>>().await
180            .unwrap()
181            .is_empty());
182        assert!(repo
183            .read_single(&WhereText::new("{\"id\":1}"))
184            .await
185            .unwrap()
186            .is_some());
187        assert!(!repo
188            .read(&WhereText::new("{\"id\":1}"))
189            .try_collect::<Vec<_>>().await
190            .unwrap()
191            .is_empty());
192        let created = repo.create(rec(2, "b")).await.unwrap();
193        assert_eq!(created.get("id"), Some(&Value::Int(2)));
194        let updated_row_1 = rec(2, "B");
195        let updated = repo.update(updated_row_1).await.unwrap();
196        assert_eq!(updated.rows_affected, 1);
197        let updated_row_2 = rec(2, "C");
198        let updated_by_where = repo
199            .update(updated_row_2)
200            .await
201            .unwrap();
202        assert_eq!(updated_by_where.rows_affected, 1);
203        let removed = repo
204            .delete(rec(2, "C"))
205            .await
206            .unwrap();
207        assert_eq!(removed.rows_affected, 1);
208
209        let command = MemoryCommand::new(conn.clone());
210        command
211            .execute("insert", Some(&[Parameter::new("id", 5_i64)]))
212            .await
213            .unwrap();
214        command
215            .execute(
216                "update",
217                Some(&[
218                    Parameter::new("id", 5_i64),
219                    Parameter::new("name", "z"),
220                    Parameter::new("$where", "{\"id\":5}"),
221                ]),
222            )
223            .await
224            .unwrap();
225        command
226            .execute("update", Some(&[Parameter::new("id", 5_i64)]))
227            .await
228            .unwrap();
229        command
230            .execute("update", Some(&[Parameter::new("$where", 1_i64)]))
231            .await
232            .unwrap();
233        command
234            .execute("delete", Some(&[Parameter::new("id", 5_i64)]))
235            .await
236            .unwrap();
237        command.execute("delete", None).await.unwrap();
238        assert!(command.execute("nope", None).await.is_err());
239        assert!(command.execute("", None).await.is_err());
240        command
241            .execute_reader("{\"id\":1}", Some(&[Parameter::new("name", "a")]))
242            .await
243            .unwrap();
244        let txn = conn.start_transaction(None).await.unwrap();
245        assert!(conn.in_transaction());
246        let rolled_back = repo.create(rec(9, "t")).await.unwrap();
247        assert_eq!(rolled_back.get("id"), Some(&Value::Int(9)));
248        txn.abort().await.unwrap();
249        let txn = conn.start_transaction(None).await.unwrap();
250        let committed = repo.create(rec(8, "c")).await.unwrap();
251        assert_eq!(committed.get("id"), Some(&Value::Int(8)));
252        txn.commit().await.unwrap();
253        let _ = conn.start_transaction(None).await.unwrap();
254        conn.finish_abort();
255        assert!(!conn.in_transaction());
256        conn.finish_abort();
257        conn.close().await.unwrap();
258        assert!(conn.ensure_open().is_err());
259
260        let named_conn = Arc::new(MemoryConnection::new(
261            Arc::new(MemoryStore::new()),
262            "users",
263            Some(MemoryData::Collections({
264                let mut map = HashMap::new();
265                map.insert("users".into(), vec![rec(1, "a")]);
266                map
267            })),
268        ));
269        named_conn.open().await.unwrap();
270        crud(named_conn.clone())
271            .create(rec(2, "b"))
272            .await
273            .unwrap();
274
275        reset();
276        register("memory", Arc::new(MemoryDriver));
277        let ds = create(Some(&HashMap::from([("PROVIDER".into(), "memory".into())]))).unwrap();
278        assert_eq!(ds.provider(), "memory");
279        ds.create_connection().await.unwrap();
280        let command = ds.create_command(None).await.unwrap();
281        command.execute("insert", None).await.unwrap();
282        command.execute_reader("", None).await.unwrap();
283        let bound = ds
284            .create_command(Some(ds.create_connection().await.unwrap()))
285            .await
286            .unwrap();
287        bound.execute("insert", None).await.unwrap();
288        bound.execute_reader("", None).await.unwrap();
289        ds.create_repository::<Row>(None, None);
290        ds.create_repository::<Row>(Some(ds.create_connection().await.unwrap()), None);
291        assert_eq!(
292            create(Some(&HashMap::from([("PROVIDER".into(), "memory".into())])))
293                .unwrap()
294                .provider(),
295            "memory"
296        );
297
298        assert!(parse_filter(None).unwrap().is_empty());
299        assert!(parse_filter(Some("   ")).unwrap().is_empty());
300        assert!(parse_filter(Some("[]")).is_err());
301        assert!(parse_filter(Some("not-json")).is_err());
302        assert!(!matches(&Row::new(), &{
303            let mut f = Row::new();
304            f.insert("id".into(), Value::Int(1));
305            f
306        }));
307        json_to_value(&JsonValue::Null);
308        json_to_value(&JsonValue::Bool(true));
309        json_to_value(&serde_json::json!(1));
310        json_to_value(&JsonValue::Number(
311            serde_json::Number::from_f64(1.25).unwrap(),
312        ));
313        json_to_value(&serde_json::json!("x"));
314        json_to_value(&serde_json::json!([1]));
315        if let JsonValue::Number(n) = serde_json::json!(1) {
316            json_to_value(&JsonValue::Number(n));
317        }
318        json_to_value(&JsonValue::Number(serde_json::Number::from(u64::MAX)));
319
320        let closed = Arc::new(MemoryConnection::new(
321            Arc::new(MemoryStore::new()),
322            "",
323            None,
324        ));
325        assert!(MemoryCommand::new(closed.clone())
326            .execute_reader("", None)
327            .await
328            .is_err());
329        assert!(MemoryCommand::new(closed.clone())
330            .execute("insert", None)
331            .await
332            .is_err());
333        let created = crud(closed.clone())
334            .create(rec(1, "a"))
335            .await
336            .expect("create opens");
337        assert!(closed.is_open());
338        assert_eq!(created.get("id"), Some(&Value::Int(1)));
339        assert!(
340            MemoryConnection::new(Arc::new(MemoryStore::new()), "", None)
341                .start_transaction(None)
342                .await
343                .is_err()
344        );
345
346        let empty = Arc::new(MemoryConnection::new(
347            Arc::new(MemoryStore::new()),
348            "",
349            None,
350        ));
351        empty.open().await.unwrap();
352        empty.finish_commit();
353        empty.finish_abort();
354    }
355}