A0-1584: Unify MockMultiaddress

finality-aleph/src/network/manager/compatibility.rs

@@ -140,11 +140,11 @@ mod test {
         crypto::AuthorityVerifier,
         network::{
             manager::{compatibility::MAX_AUTHENTICATION_SIZE, SessionHandler},
-            mock::MockMultiaddress,
             NetworkIdentity,
         },
         nodes::testing::new_pen,
         tcp_network::{testing::new_identity, TcpMultiaddress},
+        testing::mocks::validator_network::MockMultiaddress,
         NodeIndex, SessionId, Version,
     };
 

finality-aleph/src/network/manager/connections.rs

@@ -56,10 +56,13 @@ mod tests {
     use std::collections::HashSet;
 
     use super::Connections;
-    use crate::{network::mock::MockPeerId, SessionId};
+    use crate::{
+        validator_network::mock::{random_keys, MockPublicKey},
+        SessionId,
+    };
 
-    fn random_peer_ids(num: usize) -> HashSet<MockPeerId> {
-        (0..num).map(|_| MockPeerId::random()).collect()
+    fn random_peer_ids(num: usize) -> HashSet<MockPublicKey> {
+        random_keys(num).into_keys().collect()
     }
 
     #[test]

finality-aleph/src/network/manager/discovery.rs

@@ -136,10 +136,8 @@ mod tests {
 
     use super::{Discovery, DiscoveryMessage};
     use crate::{
-        network::{
-            manager::SessionHandler,
-            mock::{crypto_basics, MockMultiaddress, MockPeerId},
-        },
+        network::{manager::SessionHandler, mock::crypto_basics},
+        testing::mocks::validator_network::{random_identity, MockMultiaddress},
         SessionId,
     };
 
@@ -148,7 +146,7 @@ mod tests {
 
     fn addresses() -> Vec<MockMultiaddress> {
         (0..NUM_NODES)
-            .map(|_| MockMultiaddress::random_with_id(MockPeerId::random()))
+            .map(|_| random_identity().0[0].clone())
             .collect()
     }
 
@@ -177,7 +175,7 @@ mod tests {
             None,
             crypto_basics.1.clone(),
             SessionId(43),
-            vec![MockMultiaddress::random_with_id(MockPeerId::random())],
+            random_identity().0,
         )
         .await
         .unwrap();

finality-aleph/src/network/manager/session.rs

@@ -275,9 +275,10 @@ mod tests {
     use super::{get_common_peer_id, Handler, HandlerError};
     use crate::{
         network::{
-            mock::{crypto_basics, MockMultiaddress, MockNetworkIdentity, MockPeerId},
+            mock::{crypto_basics, MockNetworkIdentity},
             NetworkIdentity,
         },
+        testing::mocks::validator_network::{random_identity, MockMultiaddress},
         NodeIndex, SessionId,
     };
 
@@ -379,8 +380,8 @@ mod tests {
     async fn fails_to_create_with_non_unique_peer_id() {
         let mut crypto_basics = crypto_basics(NUM_NODES).await;
         let addresses = vec![
-            MockMultiaddress::random_with_id(MockPeerId::random()),
-            MockMultiaddress::random_with_id(MockPeerId::random()),
+            random_identity().0[0].clone(),
+            random_identity().0[0].clone(),
         ];
         assert!(matches!(
             Handler::new(

finality-aleph/src/network/mock.rs

@@ -7,98 +7,43 @@ use std::{
 
 use aleph_primitives::KEY_TYPE;
 use async_trait::async_trait;
-use codec::{Decode, Encode};
 use futures::{
     channel::{mpsc, oneshot},
     StreamExt,
 };
 use parking_lot::Mutex;
-use rand::random;
 use sp_keystore::{testing::KeyStore, CryptoStore};
 use tokio::time::timeout;
 
 use crate::{
     crypto::{AuthorityPen, AuthorityVerifier},
     network::{
         manager::VersionedAuthentication, AddressedData, ConnectionCommand, Event, EventStream,
-        Multiaddress, Network, NetworkIdentity, NetworkSender, NetworkServiceIO, PeerId, Protocol,
+        Multiaddress, Network, NetworkIdentity, NetworkSender, NetworkServiceIO, Protocol,
     },
+    testing::mocks::validator_network::{random_identity, MockMultiaddress},
+    validator_network::mock::MockPublicKey,
     AuthorityId, NodeIndex,
 };
 
-#[derive(PartialEq, Eq, Copy, Clone, Debug, Hash, Encode, Decode)]
-pub struct MockPeerId(u32);
-
-impl MockPeerId {
-    pub fn random() -> Self {
-        MockPeerId(random())
-    }
-}
-impl fmt::Display for MockPeerId {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl PeerId for MockPeerId {}
-
-#[derive(PartialEq, Eq, Clone, Debug, Hash, Encode, Decode)]
-pub struct MockMultiaddress {
-    peer_id: Option<MockPeerId>,
-    address: u32,
-}
-
-impl MockMultiaddress {
-    pub fn random_with_id(peer_id: MockPeerId) -> Self {
-        MockMultiaddress {
-            peer_id: Some(peer_id),
-            address: random(),
-        }
-    }
-}
-
-impl Multiaddress for MockMultiaddress {
-    type PeerId = MockPeerId;
-
-    fn get_peer_id(&self) -> Option<Self::PeerId> {
-        self.peer_id
-    }
-
-    fn add_matching_peer_id(mut self, peer_id: Self::PeerId) -> Option<Self> {
-        match self.peer_id {
-            Some(old_peer_id) => match old_peer_id == peer_id {
-                true => Some(self),
-                false => None,
-            },
-            None => {
-                self.peer_id = Some(peer_id);
-                Some(self)
-            }
-        }
-    }
-}
-
 pub struct MockNetworkIdentity {
     addresses: Vec<MockMultiaddress>,
-    peer_id: MockPeerId,
+    peer_id: MockPublicKey,
 }
 
 impl MockNetworkIdentity {
     pub fn new() -> Self {
-        let peer_id = MockPeerId::random();
-        let addresses = (0..3)
-            .map(|_| MockMultiaddress::random_with_id(peer_id))
-            .collect();
+        let (addresses, peer_id) = random_identity();
         MockNetworkIdentity { addresses, peer_id }
     }
 }
 
 impl NetworkIdentity for MockNetworkIdentity {
-    type PeerId = MockPeerId;
+    type PeerId = MockPublicKey;
     type Multiaddress = MockMultiaddress;
 
     fn identity(&self) -> (Vec<Self::Multiaddress>, Self::PeerId) {
-        (self.addresses.clone(), self.peer_id)
+        (self.addresses.clone(), self.peer_id.clone())
     }
 }
 
@@ -152,7 +97,7 @@ impl<T> Default for Channel<T> {
     }
 }
 
-pub type MockEvent = Event<MockMultiaddress, MockPeerId>;
+pub type MockEvent = Event<MockMultiaddress, MockPublicKey>;
 
 pub type MockData = Vec<u8>;
 
@@ -196,15 +141,15 @@ impl<M: Multiaddress + 'static> MockIO<M> {
 pub struct MockEventStream(mpsc::UnboundedReceiver<MockEvent>);
 
 #[async_trait]
-impl EventStream<MockMultiaddress, MockPeerId> for MockEventStream {
+impl EventStream<MockMultiaddress, MockPublicKey> for MockEventStream {
     async fn next_event(&mut self) -> Option<MockEvent> {
         self.0.next().await
     }
 }
 
 pub struct MockNetworkSender {
-    sender: mpsc::UnboundedSender<(Vec<u8>, MockPeerId, Protocol)>,
-    peer_id: MockPeerId,
+    sender: mpsc::UnboundedSender<(Vec<u8>, MockPublicKey, Protocol)>,
+    peer_id: MockPublicKey,
     protocol: Protocol,
     error: Result<(), MockSenderError>,
 }
@@ -219,7 +164,7 @@ impl NetworkSender for MockNetworkSender {
     ) -> Result<(), MockSenderError> {
         self.error?;
         self.sender
-            .unbounded_send((data.into(), self.peer_id, self.protocol))
+            .unbounded_send((data.into(), self.peer_id.clone(), self.protocol))
             .unwrap();
         Ok(())
     }
@@ -228,8 +173,8 @@ impl NetworkSender for MockNetworkSender {
 #[derive(Clone)]
 pub struct MockNetwork {
     pub add_reserved: Channel<(HashSet<MockMultiaddress>, Protocol)>,
-    pub remove_reserved: Channel<(HashSet<MockPeerId>, Protocol)>,
-    pub send_message: Channel<(Vec<u8>, MockPeerId, Protocol)>,
+    pub remove_reserved: Channel<(HashSet<MockPublicKey>, Protocol)>,
+    pub send_message: Channel<(Vec<u8>, MockPublicKey, Protocol)>,
     pub event_sinks: Arc<Mutex<Vec<mpsc::UnboundedSender<MockEvent>>>>,
     event_stream_taken_oneshot: Arc<Mutex<Option<oneshot::Sender<()>>>>,
     pub create_sender_errors: Arc<Mutex<VecDeque<MockSenderError>>>,
@@ -256,7 +201,7 @@ impl std::error::Error for MockSenderError {}
 impl Network for MockNetwork {
     type SenderError = MockSenderError;
     type NetworkSender = MockNetworkSender;
-    type PeerId = MockPeerId;
+    type PeerId = MockPublicKey;
     type Multiaddress = MockMultiaddress;
     type EventStream = MockEventStream;