Skip to main content

datasources_memory/
lib.rs

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