Add broadcast impl

src/accountant_stub.rs

@@ -10,11 +10,11 @@ use hash::Hash;
 use signature::{KeyPair, PublicKey, Signature};
 use std::collections::HashMap;
 use std::io;
-use std::net::UdpSocket;
+use std::net::{SocketAddr, UdpSocket};
 use transaction::Transaction;
 
 pub struct AccountantStub {
-    pub addr: String,
+    pub addr: SocketAddr,
     pub socket: UdpSocket,
     last_id: Option<Hash>,
     num_events: u64,
@@ -25,9 +25,9 @@ impl AccountantStub {
     /// Create a new AccountantStub that will interface with AccountantSkel
     /// over `socket`. To receive responses, the caller must bind `socket`
     /// to a public address before invoking AccountantStub methods.
-    pub fn new(addr: &str, socket: UdpSocket) -> Self {
+    pub fn new(addr: SocketAddr, socket: UdpSocket) -> Self {
         let stub = AccountantStub {
-            addr: addr.to_string(),
+            addr: addr,
             socket,
             last_id: None,
             num_events: 0,
@@ -160,6 +160,7 @@ mod tests {
     use super::*;
     use accountant::Accountant;
     use accountant_skel::AccountantSkel;
+    use crdt::ReplicatedData;
     use futures::Future;
     use historian::Historian;
     use mint::Mint;
@@ -167,32 +168,35 @@ mod tests {
     use std::io::sink;
     use std::sync::atomic::{AtomicBool, Ordering};
     use std::sync::mpsc::sync_channel;
-    use std::sync::{Arc, Mutex};
+    use std::sync::Arc;
     use std::thread::sleep;
     use std::time::Duration;
 
     // TODO: Figure out why this test sometimes hangs on TravisCI.
     #[test]
     fn test_accountant_stub() {
-        let addr = "127.0.0.1:9000";
-        let send_addr = "127.0.0.1:9001";
+        let gossip = UdpSocket::bind("0.0.0.0:0").unwrap();
+        let serve = UdpSocket::bind("0.0.0.0:0").unwrap();
+        let addr = serve.local_addr().unwrap();
+        let pubkey = KeyPair::new().pubkey();
+        let d = ReplicatedData::new(
+            pubkey,
+            gossip.local_addr().unwrap(),
+            "0.0.0.0:0".parse().unwrap(),
+            serve.local_addr().unwrap(),
+        );
+
         let alice = Mint::new(10_000);
         let acc = Accountant::new(&alice);
         let bob_pubkey = KeyPair::new().pubkey();
         let exit = Arc::new(AtomicBool::new(false));
         let (input, event_receiver) = sync_channel(10);
         let historian = Historian::new(event_receiver, &alice.last_id(), Some(30));
-        let acc = Arc::new(Mutex::new(AccountantSkel::new(
-            acc,
-            alice.last_id(),
-            sink(),
-            input,
-            historian,
-        )));
-        let _threads = AccountantSkel::serve(&acc, addr, exit.clone()).unwrap();
+        let acc = Arc::new(AccountantSkel::new(acc, alice.last_id(), input, historian));
+        let threads = AccountantSkel::serve(&acc, d, serve, gossip, exit.clone(), sink()).unwrap();
         sleep(Duration::from_millis(300));
 
-        let socket = UdpSocket::bind(send_addr).unwrap();
+        let socket = UdpSocket::bind("0.0.0.0:0").unwrap();
         socket.set_read_timeout(Some(Duration::new(5, 0))).unwrap();
 
         let mut acc = AccountantStub::new(addr, socket);
@@ -201,5 +205,8 @@ mod tests {
             .unwrap();
         assert_eq!(acc.get_balance(&bob_pubkey).wait().unwrap(), 500);
         exit.store(true, Ordering::Relaxed);
+        for t in threads {
+            t.join().unwrap();
+        }
     }
 }