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}