Move MockObserver into observe crate and expose it optionally

Right now already and even more so in the future we need a couple of
observer types solely for testing purposes. We already have MockObserver
and DummyObserver, defined in different locations but with the former
pretty much subsuming all functionality provided by the latter.
This change moves MockObserver's definition into the observe crate and
exposes it to clients using it with the newly introduced 'test' feature
enabled. This step will allow us to have a single source for types
commonly used for testing.

Author: d-e-s-o

rust/template/distributed_datalog/Cargo.toml

@@ -6,3 +6,8 @@ edition = "2018"
 [dependencies]
 observe = {path = "observe"}
 tcp_channel = {path = "tcp_channel"}
+
+[features]
+# The 'test' feature set on this crate requires the 'test' feature of
+# the `observe` crate being enabled as well.
+test = ["observe/test"]

rust/template/distributed_datalog/observe/Cargo.toml

@@ -2,3 +2,7 @@
 name = "observe"
 version = "0.1.0"
 edition = "2018"
+
+[features]
+# Expose additional types commonly used only for testing purposes.
+test = []

rust/template/distributed_datalog/observe/src/lib.rs

@@ -9,9 +9,14 @@
 
 mod observable;
 mod observer;
+#[cfg(any(test, feature = "test"))]
+mod test;
 
 pub use observable::Observable;
 pub use observable::UpdatesObservable;
 pub use observer::Observer;
 pub use observer::ObserverBox;
 pub use observer::SharedObserver;
+
+#[cfg(feature = "test")]
+pub use test::MockObserver;

rust/template/distributed_datalog/observe/src/observable.rs

@@ -72,36 +72,15 @@ where
 mod tests {
     use super::*;
 
-    use crate::Observer;
-
-    #[derive(Debug)]
-    struct DummyObserver(());
-
-    impl Observer<(), ()> for DummyObserver {
-        fn on_start(&mut self) -> Result<(), ()> {
-            Ok(())
-        }
-
-        fn on_commit(&mut self) -> Result<(), ()> {
-            Ok(())
-        }
-
-        fn on_updates<'a>(&mut self, _: Box<dyn Iterator<Item = ()> + 'a>) -> Result<(), ()> {
-            Ok(())
-        }
-
-        fn on_completed(&mut self) -> Result<(), ()> {
-            Ok(())
-        }
-    }
+    use crate::test::MockObserver;
 
     /// Test subscribing and unsubscribing for an `UpdatesObservable`.
     #[test]
     fn subscribe_unsubscribe() {
-        let mut observable = UpdatesObservable {
+        let mut observable = UpdatesObservable::<(), ()> {
             observer: Arc::new(Mutex::new(None)),
         };
-        let observer = Box::new(DummyObserver(()));
+        let observer = Box::new(MockObserver::new());
 
         assert!(observable.subscribe(observer).is_ok());
         assert!(observable.unsubscribe(&()).is_some());
@@ -110,11 +89,11 @@ mod tests {
     /// Test multiple subscriptions to an `UpdatesObservable`.
     #[test]
     fn multiple_subscribe() {
-        let mut observable = UpdatesObservable {
+        let mut observable = UpdatesObservable::<(), ()> {
             observer: Arc::new(Mutex::new(None)),
         };
-        let observer1 = Box::new(DummyObserver(()));
-        let observer2 = Box::new(DummyObserver(()));
+        let observer1 = Box::new(MockObserver::new());
+        let observer2 = Box::new(MockObserver::new());
 
         assert!(observable.subscribe(observer1).is_ok());
         assert!(observable.subscribe(observer2).is_err());

rust/template/distributed_datalog/observe/src/test.rs

@@ -0,0 +1,46 @@
+use crate::Observer;
+
+#[derive(Clone, Debug, Default)]
+pub struct MockObserver {
+    pub called_on_start: usize,
+    pub called_on_commit: usize,
+    pub called_on_updates: usize,
+    pub called_on_completed: usize,
+}
+
+impl MockObserver {
+    pub fn new() -> Self {
+        Self {
+            called_on_start: 0,
+            called_on_commit: 0,
+            called_on_updates: 0,
+            called_on_completed: 0,
+        }
+    }
+}
+
+impl<T, E> Observer<T, E> for MockObserver
+where
+    T: Send,
+    E: Send,
+{
+    fn on_start(&mut self) -> Result<(), E> {
+        self.called_on_start += 1;
+        Ok(())
+    }
+
+    fn on_commit(&mut self) -> Result<(), E> {
+        self.called_on_commit += 1;
+        Ok(())
+    }
+
+    fn on_updates<'a>(&mut self, updates: Box<dyn Iterator<Item = T> + 'a>) -> Result<(), E> {
+        self.called_on_updates += updates.count();
+        Ok(())
+    }
+
+    fn on_completed(&mut self) -> Result<(), E> {
+        self.called_on_completed += 1;
+        Ok(())
+    }
+}

rust/template/distributed_datalog/src/lib.rs

@@ -5,3 +5,6 @@ pub use observe::SharedObserver;
 pub use observe::UpdatesObservable;
 pub use tcp_channel::TcpReceiver;
 pub use tcp_channel::TcpSender;
+
+#[cfg(feature = "test")]
+pub use observe::MockObserver;

src/Language/DifferentialDatalog/Compile.hs

@@ -164,6 +164,7 @@ rustLibFiles specname =
         , (dir </> "distributed_datalog/observe/src/lib.rs"          , $(embedFile "rust/template/distributed_datalog/observe/src/lib.rs"))
         , (dir </> "distributed_datalog/observe/src/observable.rs"   , $(embedFile "rust/template/distributed_datalog/observe/src/observable.rs"))
         , (dir </> "distributed_datalog/observe/src/observer.rs"     , $(embedFile "rust/template/distributed_datalog/observe/src/observer.rs"))
+        , (dir </> "distributed_datalog/observe/src/test.rs"         , $(embedFile "rust/template/distributed_datalog/observe/src/test.rs"))
         , (dir </> "distributed_datalog/tcp_channel/Cargo.toml"      , $(embedFile "rust/template/distributed_datalog/tcp_channel/Cargo.toml"))
         , (dir </> "distributed_datalog/tcp_channel/src/lib.rs"      , $(embedFile "rust/template/distributed_datalog/tcp_channel/src/lib.rs"))
         , (dir </> "distributed_datalog/tcp_channel/src/message.rs"  , $(embedFile "rust/template/distributed_datalog/tcp_channel/src/message.rs"))

test/datalog_tests/server_api/Cargo.toml

@@ -5,7 +5,7 @@ edition = "2018"
 
 [dependencies]
 differential_datalog = {path = "../server_api_ddlog/differential_datalog"}
-distributed_datalog = {path = "../server_api_ddlog/distributed_datalog"}
+distributed_datalog = {path = "../server_api_ddlog/distributed_datalog", features=["test"]}
 maplit = "1.0"
 server_api = {path = "../server_api_ddlog"}
 

test/datalog_tests/server_api/tests/events.rs

@@ -8,6 +8,7 @@ use differential_datalog::program::Update;
 use differential_datalog::record::Record;
 use differential_datalog::record::RelIdentifier;
 use differential_datalog::record::UpdCmd;
+use distributed_datalog::MockObserver as Mock;
 use distributed_datalog::Observable;
 use distributed_datalog::Observer;
 use distributed_datalog::SharedObserver;
@@ -28,51 +29,6 @@ use test_env_log::test;
 
 use waitfor::wait_for;
 
-#[derive(Clone, Debug)]
-struct Mock {
-    called_on_start: usize,
-    called_on_commit: usize,
-    called_on_updates: usize,
-    called_on_completed: usize,
-}
-
-impl Mock {
-    fn new() -> Self {
-        Self {
-            called_on_start: 0,
-            called_on_commit: 0,
-            called_on_updates: 0,
-            called_on_completed: 0,
-        }
-    }
-}
-
-impl<T, E> Observer<T, E> for Mock
-where
-    T: Send,
-    E: Send,
-{
-    fn on_start(&mut self) -> Result<(), E> {
-        self.called_on_start += 1;
-        Ok(())
-    }
-
-    fn on_commit(&mut self) -> Result<(), E> {
-        self.called_on_commit += 1;
-        Ok(())
-    }
-
-    fn on_updates<'a>(&mut self, updates: Box<dyn Iterator<Item = T> + 'a>) -> Result<(), E> {
-        self.called_on_updates += updates.count();
-        Ok(())
-    }
-
-    fn on_completed(&mut self) -> Result<(), E> {
-        self.called_on_completed += 1;
-        Ok(())
-    }
-}
-
 type MockObserver = SharedObserver<Mock>;
 
 fn await_expected<F>(mut op: F)