From 83293f1441573c8714ba4bac8293a9f0c28e3901 Mon Sep 17 00:00:00 2001 From: Arun Kulshreshtha Date: Wed, 8 Nov 2017 12:22:49 -0800 Subject: [PATCH] Add Core to test harness in bookmarks-test Summary: The `Bookmarks` trait assumes that the underlying implementation is asynchronous (as evidenced by the fact that all methods return `Future`s). Most non-toy implementations of an asynchronous bookmark store will need to schedule arbitrary tasks on the Core executing the returned Futures. (In some cases, the constructor itself may need to schedule tasks on the Core.) As such, this test harness should expose a Core to each test in a first class way (rather than trying to shoehorn it in via the `state`, which doesn't actually quite work here). Existing implementations can just ignore the Core. Reviewed By: jsgf Differential Revision: D6215855 fbshipit-source-id: ea3f28bdaec667111b384db29d0c7c49954398e5 --- bookmarks/test/main.rs | 83 +++++++++++++++++++++++++++--------------- 1 file changed, 53 insertions(+), 30 deletions(-) diff --git a/bookmarks/test/main.rs b/bookmarks/test/main.rs index 7d7346da4d..387bd9d6ea 100644 --- a/bookmarks/test/main.rs +++ b/bookmarks/test/main.rs @@ -10,21 +10,26 @@ extern crate futures; extern crate tempdir; +extern crate tokio_core; extern crate bookmarks; extern crate filebookmarks; extern crate membookmarks; extern crate storage_types; -use futures::{Future, Stream}; +use std::cell::RefCell; +use std::rc::Rc; + +use futures::Stream; use tempdir::TempDir; +use tokio_core::reactor::Core; use bookmarks::BookmarksMut; use filebookmarks::FileBookmarks; use membookmarks::MemBookmarks; use storage_types::Version; -fn basic(bookmarks: B) +fn basic(bookmarks: B, core: &mut Core) where B: BookmarksMut, { @@ -33,37 +38,44 @@ where let two = "2".to_string(); let three = "3".to_string(); - assert_eq!(bookmarks.get(&foo).wait().unwrap(), None); + assert_eq!(core.run(bookmarks.get(&foo)).unwrap(), None); let absent = Version::absent(); - let foo_v1 = bookmarks.set(&foo, &one, &absent).wait().unwrap().unwrap(); + let foo_v1 = core.run(bookmarks.set(&foo, &one, &absent)) + .unwrap() + .unwrap(); assert_eq!( - bookmarks.get(&foo).wait().unwrap(), + core.run(bookmarks.get(&foo)).unwrap(), Some((one.clone(), foo_v1)) ); - let foo_v2 = bookmarks.set(&foo, &two, &foo_v1).wait().unwrap().unwrap(); + let foo_v2 = core.run(bookmarks.set(&foo, &two, &foo_v1)) + .unwrap() + .unwrap(); // Should fail due to version mismatch. - assert_eq!(bookmarks.set(&foo, &three, &foo_v1).wait().unwrap(), None); + assert_eq!( + core.run(bookmarks.set(&foo, &three, &foo_v1)).unwrap(), + None + ); assert_eq!( - bookmarks.delete(&foo, &foo_v2).wait().unwrap().unwrap(), + core.run(bookmarks.delete(&foo, &foo_v2)).unwrap().unwrap(), absent ); - assert_eq!(bookmarks.get(&foo).wait().unwrap(), None); + assert_eq!(core.run(bookmarks.get(&foo)).unwrap(), None); // Even though bookmark doesn't exist, this should fail with a version mismatch. - assert_eq!(bookmarks.delete(&foo, &foo_v2).wait().unwrap(), None); + assert_eq!(core.run(bookmarks.delete(&foo, &foo_v2)).unwrap(), None); // Deleting it with the absent version should work. assert_eq!( - bookmarks.delete(&foo, &absent).wait().unwrap().unwrap(), + core.run(bookmarks.delete(&foo, &absent)).unwrap().unwrap(), absent ); } -fn list(bookmarks: B) +fn list(bookmarks: B, core: &mut Core) where B: BookmarksMut, { @@ -71,30 +83,24 @@ where let two = b"2"; let three = b"3"; - let _ = bookmarks - .create(&one, &"foo".to_string()) - .wait() + let _ = core.run(bookmarks.create(&one, &"foo".to_string())) .unwrap() .unwrap(); - let _ = bookmarks - .create(&two, &"bar".to_string()) - .wait() + let _ = core.run(bookmarks.create(&two, &"bar".to_string())) .unwrap() .unwrap(); - let _ = bookmarks - .create(&three, &"baz".to_string()) - .wait() + let _ = core.run(bookmarks.create(&three, &"baz".to_string())) .unwrap() .unwrap(); - let mut result = bookmarks.keys().collect().wait().unwrap(); + let mut result = core.run(bookmarks.keys().collect()).unwrap(); result.sort(); let expected = vec![one, two, three]; assert_eq!(result, expected); } -fn persistence(mut new_bookmarks: F) +fn persistence(mut new_bookmarks: F, core: Rc>) where F: FnMut() -> B, B: BookmarksMut, @@ -104,11 +110,17 @@ where let version = { let bookmarks = new_bookmarks(); - bookmarks.create(&foo, &bar).wait().unwrap().unwrap() + core.borrow_mut() + .run(bookmarks.create(&foo, &bar)) + .unwrap() + .unwrap() }; let bookmarks = new_bookmarks(); - assert_eq!(bookmarks.get(&foo).wait().unwrap(), Some((bar, version))); + assert_eq!( + core.borrow_mut().run(bookmarks.get(&foo)).unwrap(), + Some((bar, version)) + ); } macro_rules! bookmarks_test_impl { @@ -122,22 +134,33 @@ macro_rules! bookmarks_test_impl { #[test] fn test_basic() { + let mut core = Core::new().unwrap(); let state = $state; - basic($new_cb(&state)); + let bookmarks = $new_cb(&state, &mut core); + basic(bookmarks, &mut core); } #[test] fn test_list() { + let mut core = Core::new().unwrap(); let state = $state; - list($new_cb(&state)); + let bookmarks = $new_cb(&state, &mut core); + list(bookmarks, &mut core); } #[test] fn test_persistence() { // Not all bookmark implementations support persistence. if $persistent { + let core = Rc::new(RefCell::new(Core::new().unwrap())); let state = $state; - persistence(|| $new_cb(&state)); + let new_bookmarks = { + let core = Rc::clone(&core); + move || { + $new_cb(&state, &mut *core.borrow_mut()) + } + }; + persistence(new_bookmarks, core); } } } @@ -147,7 +170,7 @@ macro_rules! bookmarks_test_impl { bookmarks_test_impl! { membookmarks_test => { state: (), - new: |_| MemBookmarks::new(), + new: |_, _| MemBookmarks::new(), persistent: false, } } @@ -155,7 +178,7 @@ bookmarks_test_impl! { bookmarks_test_impl! { filebookmarks_test => { state: TempDir::new("filebookmarks_test").unwrap(), - new: |dir: &TempDir| FileBookmarks::open(dir.as_ref()).unwrap(), + new: |dir: &TempDir, _| FileBookmarks::open(dir.as_ref()).unwrap(), persistent: true, } }