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, ICRUDRepository, IReadonlyRepository,
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}