network: fix tests

andresilva · andresilva · commit bb224d763bbc · 2019-03-25T21:31:35.000Z
diff --git a/network/src/tests.rs b/network/src/tests.rs
@@ -26,7 +26,7 @@ use polkadot_primitives::parachain::{CandidateReceipt, CollatorId, HeadData, Blo
 use substrate_primitives::crypto::UncheckedInto;
 use codec::Encode;
 use substrate_network::{
-	Severity, NodeIndex, PeerInfo, ClientHandle, Context, config::Roles,
+	Severity, PeerId, PeerInfo, ClientHandle, Context, config::Roles,
 	message::Message as SubstrateMessage, specialization::NetworkSpecialization,
 	generic_message::Message as GenericMessage
 };
@@ -36,34 +36,34 @@ use futures::Future;
 
 #[derive(Default)]
 struct TestContext {
-	disabled: Vec<NodeIndex>,
-	disconnected: Vec<NodeIndex>,
-	messages: Vec<(NodeIndex, SubstrateMessage<Block>)>,
+	disabled: Vec<PeerId>,
+	disconnected: Vec<PeerId>,
+	messages: Vec<(PeerId, SubstrateMessage<Block>)>,
 }
 
 impl Context<Block> for TestContext {
 	fn client(&self) -> &ClientHandle<Block> {
 		unimplemented!()
 	}
 
-	fn report_peer(&mut self, peer: NodeIndex, reason: Severity) {
+	fn report_peer(&mut self, peer: PeerId, reason: Severity) {
 		match reason {
 			Severity::Bad(_) => self.disabled.push(peer),
 			_ => self.disconnected.push(peer),
 		}
 	}
 
-	fn peer_info(&self, _peer: NodeIndex) -> Option<PeerInfo<Block>> {
+	fn peer_info(&self, _peer: &PeerId) -> Option<PeerInfo<Block>> {
 		unimplemented!()
 	}
 
-	fn send_message(&mut self, who: NodeIndex, data: SubstrateMessage<Block>) {
+	fn send_message(&mut self, who: PeerId, data: SubstrateMessage<Block>) {
 		self.messages.push((who, data))
 	}
 }
 
 impl TestContext {
-	fn has_message(&self, to: NodeIndex, message: Message) -> bool {
+	fn has_message(&self, to: PeerId, message: Message) -> bool {
 		use substrate_network::generic_message::Message as GenericMessage;
 
 		let encoded = message.encode();
@@ -93,7 +93,7 @@ fn make_consensus(local_key: SessionKey) -> (CurrentConsensus, Arc<Mutex<Knowled
 	(c, knowledge)
 }
 
-fn on_message(protocol: &mut PolkadotProtocol, ctx: &mut TestContext, from: NodeIndex, message: Message) {
+fn on_message(protocol: &mut PolkadotProtocol, ctx: &mut TestContext, from: PeerId, message: Message) {
 	let encoded = message.encode();
 	protocol.on_message(ctx, from, &mut Some(GenericMessage::ChainSpecific(encoded)));
 }
@@ -102,8 +102,8 @@ fn on_message(protocol: &mut PolkadotProtocol, ctx: &mut TestContext, from: Node
 fn sends_session_key() {
 	let mut protocol = PolkadotProtocol::new(None);
 
-	let peer_a = 1;
-	let peer_b = 2;
+	let peer_a = PeerId::random();
+	let peer_b = PeerId::random();
 	let parent_hash = [0; 32].into();
 	let local_key: SessionKey = [1; 32].unchecked_into();
 
@@ -112,30 +112,30 @@ fn sends_session_key() {
 
 	{
 		let mut ctx = TestContext::default();
-		protocol.on_connect(&mut ctx, peer_a, make_status(&validator_status, Roles::AUTHORITY));
+		protocol.on_connect(&mut ctx, peer_a.clone(), make_status(&validator_status, Roles::AUTHORITY));
 		assert!(ctx.messages.is_empty());
 	}
 
 	{
 		let mut ctx = TestContext::default();
 		let (consensus, _knowledge) = make_consensus(local_key.clone());
 		protocol.new_consensus(&mut ctx, parent_hash, consensus);
-		assert!(ctx.has_message(peer_a, Message::SessionKey(local_key.clone())));
+		assert!(ctx.has_message(peer_a.clone(), Message::SessionKey(local_key.clone())));
 	}
 
 	{
 		let mut ctx = TestContext::default();
-		protocol.on_connect(&mut ctx, peer_b, make_status(&collator_status, Roles::NONE));
-		assert!(ctx.has_message(peer_b, Message::SessionKey(local_key)));
+		protocol.on_connect(&mut ctx, peer_b.clone(), make_status(&collator_status, Roles::NONE));
+		assert!(ctx.has_message(peer_b.clone(), Message::SessionKey(local_key)));
 	}
 }
 
 #[test]
 fn fetches_from_those_with_knowledge() {
 	let mut protocol = PolkadotProtocol::new(None);
 
-	let peer_a = 1;
-	let peer_b = 2;
+	let peer_a = PeerId::random();
+	let peer_b = PeerId::random();
 	let parent_hash = [0; 32].into();
 	let local_key: SessionKey = [1; 32].unchecked_into();
 
@@ -167,35 +167,35 @@ fn fetches_from_those_with_knowledge() {
 	// connect peer A
 	{
 		let mut ctx = TestContext::default();
-		protocol.on_connect(&mut ctx, peer_a, make_status(&status, Roles::AUTHORITY));
-		assert!(ctx.has_message(peer_a, Message::SessionKey(local_key)));
+		protocol.on_connect(&mut ctx, peer_a.clone(), make_status(&status, Roles::AUTHORITY));
+		assert!(ctx.has_message(peer_a.clone(), Message::SessionKey(local_key)));
 	}
 
 	// peer A gives session key and gets asked for data.
 	{
 		let mut ctx = TestContext::default();
-		on_message(&mut protocol, &mut ctx, peer_a, Message::SessionKey(a_key.clone()));
+		on_message(&mut protocol, &mut ctx, peer_a.clone(), Message::SessionKey(a_key.clone()));
 		assert!(protocol.validators.contains_key(&a_key));
-		assert!(ctx.has_message(peer_a, Message::RequestBlockData(1, parent_hash, candidate_hash)));
+		assert!(ctx.has_message(peer_a.clone(), Message::RequestBlockData(1, parent_hash, candidate_hash)));
 	}
 
 	knowledge.lock().note_statement(b_key.clone(), &GenericStatement::Valid(candidate_hash));
 
 	// peer B connects and sends session key. request already assigned to A
 	{
 		let mut ctx = TestContext::default();
-		protocol.on_connect(&mut ctx, peer_b, make_status(&status, Roles::AUTHORITY));
-		on_message(&mut protocol, &mut ctx, peer_b, Message::SessionKey(b_key.clone()));
-		assert!(!ctx.has_message(peer_b, Message::RequestBlockData(2, parent_hash, candidate_hash)));
+		protocol.on_connect(&mut ctx, peer_b.clone(), make_status(&status, Roles::AUTHORITY));
+		on_message(&mut protocol, &mut ctx, peer_b.clone(), Message::SessionKey(b_key.clone()));
+		assert!(!ctx.has_message(peer_b.clone(), Message::RequestBlockData(2, parent_hash, candidate_hash)));
 
 	}
 
 	// peer A disconnects, triggering reassignment
 	{
 		let mut ctx = TestContext::default();
-		protocol.on_disconnect(&mut ctx, peer_a);
+		protocol.on_disconnect(&mut ctx, peer_a.clone());
 		assert!(!protocol.validators.contains_key(&a_key));
-		assert!(ctx.has_message(peer_b, Message::RequestBlockData(2, parent_hash, candidate_hash)));
+		assert!(ctx.has_message(peer_b.clone(), Message::RequestBlockData(2, parent_hash, candidate_hash)));
 	}
 
 	// peer B comes back with block data.
@@ -211,7 +211,7 @@ fn fetches_from_those_with_knowledge() {
 fn fetches_available_block_data() {
 	let mut protocol = PolkadotProtocol::new(None);
 
-	let peer_a = 1;
+	let peer_a = PeerId::random();
 	let parent_hash = [0; 32].into();
 
 	let block_data = BlockData(vec![1, 2, 3, 4]);
@@ -246,13 +246,13 @@ fn fetches_available_block_data() {
 	// connect peer A
 	{
 		let mut ctx = TestContext::default();
-		protocol.on_connect(&mut ctx, peer_a, make_status(&status, Roles::FULL));
+		protocol.on_connect(&mut ctx, peer_a.clone(), make_status(&status, Roles::FULL));
 	}
 
 	// peer A asks for historic block data and gets response
 	{
 		let mut ctx = TestContext::default();
-		on_message(&mut protocol, &mut ctx, peer_a, Message::RequestBlockData(1, parent_hash, candidate_hash));
+		on_message(&mut protocol, &mut ctx, peer_a.clone(), Message::RequestBlockData(1, parent_hash, candidate_hash));
 		assert!(ctx.has_message(peer_a, Message::BlockData(1, Some(block_data))));
 	}
 }
@@ -261,14 +261,14 @@ fn fetches_available_block_data() {
 fn remove_bad_collator() {
 	let mut protocol = PolkadotProtocol::new(None);
 
-	let who = 1;
+	let who = PeerId::random();
 	let account_id: CollatorId = [2; 32].unchecked_into();
 
 	let status = Status { collating_for: Some((account_id.clone(), 5.into())) };
 
 	{
 		let mut ctx = TestContext::default();
-		protocol.on_connect(&mut ctx, who, make_status(&status, Roles::NONE));
+		protocol.on_connect(&mut ctx, who.clone(), make_status(&status, Roles::NONE));
 	}
 
 	{
@@ -296,30 +296,30 @@ fn many_session_keys() {
 
 	assert_eq!(protocol.live_consensus.recent_keys(), &[local_key_a.clone(), local_key_b.clone()]);
 
-	let peer_a = 1;
+	let peer_a = PeerId::random();
 
 	// when connecting a peer, we should get both those keys.
 	{
 		let mut ctx = TestContext::default();
 
 		let status = Status { collating_for: None };
-		protocol.on_connect(&mut ctx, peer_a, make_status(&status, Roles::AUTHORITY));
+		protocol.on_connect(&mut ctx, peer_a.clone(), make_status(&status, Roles::AUTHORITY));
 
-		assert!(ctx.has_message(peer_a, Message::SessionKey(local_key_a.clone())));
+		assert!(ctx.has_message(peer_a.clone(), Message::SessionKey(local_key_a.clone())));
 		assert!(ctx.has_message(peer_a, Message::SessionKey(local_key_b.clone())));
 	}
 
-	let peer_b = 2;
+	let peer_b = PeerId::random();
 
 	protocol.remove_consensus(&parent_a);
 
 	{
 		let mut ctx = TestContext::default();
 
 		let status = Status { collating_for: None };
-		protocol.on_connect(&mut ctx, peer_b, make_status(&status, Roles::AUTHORITY));
+		protocol.on_connect(&mut ctx, peer_b.clone(), make_status(&status, Roles::AUTHORITY));
 
-		assert!(!ctx.has_message(peer_b, Message::SessionKey(local_key_a.clone())));
+		assert!(!ctx.has_message(peer_b.clone(), Message::SessionKey(local_key_a.clone())));
 		assert!(ctx.has_message(peer_b, Message::SessionKey(local_key_b.clone())));
 	}
 }

Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ use polkadot_primitives::parachain::{CandidateReceipt, CollatorId, HeadData, Blo`
`26`	`26`	`use substrate_primitives::crypto::UncheckedInto;`
`27`	`27`	`use codec::Encode;`
`28`	`28`	`use substrate_network::{`
`29`		`- Severity, NodeIndex, PeerInfo, ClientHandle, Context, config::Roles,`
	`29`	`+ Severity, PeerId, PeerInfo, ClientHandle, Context, config::Roles,`
`30`	`30`	`message::Message as SubstrateMessage, specialization::NetworkSpecialization,`
`31`	`31`	`generic_message::Message as GenericMessage`
`32`	`32`	`};`
`@@ -36,34 +36,34 @@ use futures::Future;`
`36`	`36`
`37`	`37`	`#[derive(Default)]`
`38`	`38`	`struct TestContext {`
`39`		`- disabled: Vec<NodeIndex>,`
`40`		`- disconnected: Vec<NodeIndex>,`
`41`		`- messages: Vec<(NodeIndex, SubstrateMessage<Block>)>,`
	`39`	`+ disabled: Vec<PeerId>,`
	`40`	`+ disconnected: Vec<PeerId>,`
	`41`	`+ messages: Vec<(PeerId, SubstrateMessage<Block>)>,`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`impl Context<Block> for TestContext {`
`45`	`45`	`fn client(&self) -> &ClientHandle<Block> {`
`46`	`46`	`unimplemented!()`
`47`	`47`	`}`
`48`	`48`
`49`		`- fn report_peer(&mut self, peer: NodeIndex, reason: Severity) {`
	`49`	`+ fn report_peer(&mut self, peer: PeerId, reason: Severity) {`
`50`	`50`	`match reason {`
`51`	`51`	`Severity::Bad(_) => self.disabled.push(peer),`
`52`	`52`	`_ => self.disconnected.push(peer),`
`53`	`53`	`}`
`54`	`54`	`}`
`55`	`55`
`56`		`- fn peer_info(&self, _peer: NodeIndex) -> Option<PeerInfo<Block>> {`
	`56`	`+ fn peer_info(&self, _peer: &PeerId) -> Option<PeerInfo<Block>> {`
`57`	`57`	`unimplemented!()`
`58`	`58`	`}`
`59`	`59`
`60`		`- fn send_message(&mut self, who: NodeIndex, data: SubstrateMessage<Block>) {`
	`60`	`+ fn send_message(&mut self, who: PeerId, data: SubstrateMessage<Block>) {`
`61`	`61`	`self.messages.push((who, data))`
`62`	`62`	`}`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`impl TestContext {`
`66`		`- fn has_message(&self, to: NodeIndex, message: Message) -> bool {`
	`66`	`+ fn has_message(&self, to: PeerId, message: Message) -> bool {`
`67`	`67`	`use substrate_network::generic_message::Message as GenericMessage;`
`68`	`68`
`69`	`69`	`let encoded = message.encode();`
`@@ -93,7 +93,7 @@ fn make_consensus(local_key: SessionKey) -> (CurrentConsensus, Arc<Mutex<Knowled`
`93`	`93`	`(c, knowledge)`
`94`	`94`	`}`
`95`	`95`
`96`		`-fn on_message(protocol: &mut PolkadotProtocol, ctx: &mut TestContext, from: NodeIndex, message: Message) {`
	`96`	`+fn on_message(protocol: &mut PolkadotProtocol, ctx: &mut TestContext, from: PeerId, message: Message) {`
`97`	`97`	`let encoded = message.encode();`
`98`	`98`	`protocol.on_message(ctx, from, &mut Some(GenericMessage::ChainSpecific(encoded)));`
`99`	`99`	`}`
`@@ -102,8 +102,8 @@ fn on_message(protocol: &mut PolkadotProtocol, ctx: &mut TestContext, from: Node`
`102`	`102`	`fn sends_session_key() {`
`103`	`103`	`let mut protocol = PolkadotProtocol::new(None);`
`104`	`104`
`105`		`- let peer_a = 1;`
`106`		`- let peer_b = 2;`
	`105`	`+ let peer_a = PeerId::random();`
	`106`	`+ let peer_b = PeerId::random();`
`107`	`107`	`let parent_hash = [0; 32].into();`
`108`	`108`	`let local_key: SessionKey = [1; 32].unchecked_into();`
`109`	`109`
`@@ -112,30 +112,30 @@ fn sends_session_key() {`
`112`	`112`
`113`	`113`	`{`
`114`	`114`	`let mut ctx = TestContext::default();`
`115`		`- protocol.on_connect(&mut ctx, peer_a, make_status(&validator_status, Roles::AUTHORITY));`
	`115`	`+ protocol.on_connect(&mut ctx, peer_a.clone(), make_status(&validator_status, Roles::AUTHORITY));`
`116`	`116`	`assert!(ctx.messages.is_empty());`
`117`	`117`	`}`
`118`	`118`
`119`	`119`	`{`
`120`	`120`	`let mut ctx = TestContext::default();`
`121`	`121`	`let (consensus, _knowledge) = make_consensus(local_key.clone());`
`122`	`122`	`protocol.new_consensus(&mut ctx, parent_hash, consensus);`
`123`		`- assert!(ctx.has_message(peer_a, Message::SessionKey(local_key.clone())));`
	`123`	`+ assert!(ctx.has_message(peer_a.clone(), Message::SessionKey(local_key.clone())));`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`{`
`127`	`127`	`let mut ctx = TestContext::default();`
`128`		`- protocol.on_connect(&mut ctx, peer_b, make_status(&collator_status, Roles::NONE));`
`129`		`- assert!(ctx.has_message(peer_b, Message::SessionKey(local_key)));`
	`128`	`+ protocol.on_connect(&mut ctx, peer_b.clone(), make_status(&collator_status, Roles::NONE));`
	`129`	`+ assert!(ctx.has_message(peer_b.clone(), Message::SessionKey(local_key)));`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`133`	`133`	`#[test]`
`134`	`134`	`fn fetches_from_those_with_knowledge() {`
`135`	`135`	`let mut protocol = PolkadotProtocol::new(None);`
`136`	`136`
`137`		`- let peer_a = 1;`
`138`		`- let peer_b = 2;`
	`137`	`+ let peer_a = PeerId::random();`
	`138`	`+ let peer_b = PeerId::random();`
`139`	`139`	`let parent_hash = [0; 32].into();`
`140`	`140`	`let local_key: SessionKey = [1; 32].unchecked_into();`
`141`	`141`
`@@ -167,35 +167,35 @@ fn fetches_from_those_with_knowledge() {`
`167`	`167`	`// connect peer A`
`168`	`168`	`{`
`169`	`169`	`let mut ctx = TestContext::default();`
`170`		`- protocol.on_connect(&mut ctx, peer_a, make_status(&status, Roles::AUTHORITY));`
`171`		`- assert!(ctx.has_message(peer_a, Message::SessionKey(local_key)));`
	`170`	`+ protocol.on_connect(&mut ctx, peer_a.clone(), make_status(&status, Roles::AUTHORITY));`
	`171`	`+ assert!(ctx.has_message(peer_a.clone(), Message::SessionKey(local_key)));`
`172`	`172`	`}`
`173`	`173`
`174`	`174`	`// peer A gives session key and gets asked for data.`
`175`	`175`	`{`
`176`	`176`	`let mut ctx = TestContext::default();`
`177`		`- on_message(&mut protocol, &mut ctx, peer_a, Message::SessionKey(a_key.clone()));`
	`177`	`+ on_message(&mut protocol, &mut ctx, peer_a.clone(), Message::SessionKey(a_key.clone()));`
`178`	`178`	`assert!(protocol.validators.contains_key(&a_key));`
`179`		`- assert!(ctx.has_message(peer_a, Message::RequestBlockData(1, parent_hash, candidate_hash)));`
	`179`	`+ assert!(ctx.has_message(peer_a.clone(), Message::RequestBlockData(1, parent_hash, candidate_hash)));`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`knowledge.lock().note_statement(b_key.clone(), &GenericStatement::Valid(candidate_hash));`
`183`	`183`
`184`	`184`	`// peer B connects and sends session key. request already assigned to A`
`185`	`185`	`{`
`186`	`186`	`let mut ctx = TestContext::default();`
`187`		`- protocol.on_connect(&mut ctx, peer_b, make_status(&status, Roles::AUTHORITY));`
`188`		`- on_message(&mut protocol, &mut ctx, peer_b, Message::SessionKey(b_key.clone()));`
`189`		`- assert!(!ctx.has_message(peer_b, Message::RequestBlockData(2, parent_hash, candidate_hash)));`
	`187`	`+ protocol.on_connect(&mut ctx, peer_b.clone(), make_status(&status, Roles::AUTHORITY));`
	`188`	`+ on_message(&mut protocol, &mut ctx, peer_b.clone(), Message::SessionKey(b_key.clone()));`
	`189`	`+ assert!(!ctx.has_message(peer_b.clone(), Message::RequestBlockData(2, parent_hash, candidate_hash)));`
`190`	`190`
`191`	`191`	`}`
`192`	`192`
`193`	`193`	`// peer A disconnects, triggering reassignment`
`194`	`194`	`{`
`195`	`195`	`let mut ctx = TestContext::default();`
`196`		`- protocol.on_disconnect(&mut ctx, peer_a);`
	`196`	`+ protocol.on_disconnect(&mut ctx, peer_a.clone());`
`197`	`197`	`assert!(!protocol.validators.contains_key(&a_key));`
`198`		`- assert!(ctx.has_message(peer_b, Message::RequestBlockData(2, parent_hash, candidate_hash)));`
	`198`	`+ assert!(ctx.has_message(peer_b.clone(), Message::RequestBlockData(2, parent_hash, candidate_hash)));`
`199`	`199`	`}`
`200`	`200`
`201`	`201`	`// peer B comes back with block data.`
`@@ -211,7 +211,7 @@ fn fetches_from_those_with_knowledge() {`
`211`	`211`	`fn fetches_available_block_data() {`
`212`	`212`	`let mut protocol = PolkadotProtocol::new(None);`
`213`	`213`
`214`		`- let peer_a = 1;`
	`214`	`+ let peer_a = PeerId::random();`
`215`	`215`	`let parent_hash = [0; 32].into();`
`216`	`216`
`217`	`217`	`let block_data = BlockData(vec![1, 2, 3, 4]);`
`@@ -246,13 +246,13 @@ fn fetches_available_block_data() {`
`246`	`246`	`// connect peer A`
`247`	`247`	`{`
`248`	`248`	`let mut ctx = TestContext::default();`
`249`		`- protocol.on_connect(&mut ctx, peer_a, make_status(&status, Roles::FULL));`
	`249`	`+ protocol.on_connect(&mut ctx, peer_a.clone(), make_status(&status, Roles::FULL));`
`250`	`250`	`}`
`251`	`251`
`252`	`252`	`// peer A asks for historic block data and gets response`
`253`	`253`	`{`
`254`	`254`	`let mut ctx = TestContext::default();`
`255`		`- on_message(&mut protocol, &mut ctx, peer_a, Message::RequestBlockData(1, parent_hash, candidate_hash));`
	`255`	`+ on_message(&mut protocol, &mut ctx, peer_a.clone(), Message::RequestBlockData(1, parent_hash, candidate_hash));`
`256`	`256`	`assert!(ctx.has_message(peer_a, Message::BlockData(1, Some(block_data))));`
`257`	`257`	`}`
`258`	`258`	`}`
`@@ -261,14 +261,14 @@ fn fetches_available_block_data() {`
`261`	`261`	`fn remove_bad_collator() {`
`262`	`262`	`let mut protocol = PolkadotProtocol::new(None);`
`263`	`263`
`264`		`- let who = 1;`
	`264`	`+ let who = PeerId::random();`
`265`	`265`	`let account_id: CollatorId = [2; 32].unchecked_into();`
`266`	`266`
`267`	`267`	`let status = Status { collating_for: Some((account_id.clone(), 5.into())) };`
`268`	`268`
`269`	`269`	`{`
`270`	`270`	`let mut ctx = TestContext::default();`
`271`		`- protocol.on_connect(&mut ctx, who, make_status(&status, Roles::NONE));`
	`271`	`+ protocol.on_connect(&mut ctx, who.clone(), make_status(&status, Roles::NONE));`
`272`	`272`	`}`
`273`	`273`
`274`	`274`	`{`
`@@ -296,30 +296,30 @@ fn many_session_keys() {`
`296`	`296`
`297`	`297`	`assert_eq!(protocol.live_consensus.recent_keys(), &[local_key_a.clone(), local_key_b.clone()]);`
`298`	`298`
`299`		`- let peer_a = 1;`
	`299`	`+ let peer_a = PeerId::random();`
`300`	`300`
`301`	`301`	`// when connecting a peer, we should get both those keys.`
`302`	`302`	`{`
`303`	`303`	`let mut ctx = TestContext::default();`
`304`	`304`
`305`	`305`	`let status = Status { collating_for: None };`
`306`		`- protocol.on_connect(&mut ctx, peer_a, make_status(&status, Roles::AUTHORITY));`
	`306`	`+ protocol.on_connect(&mut ctx, peer_a.clone(), make_status(&status, Roles::AUTHORITY));`
`307`	`307`
`308`		`- assert!(ctx.has_message(peer_a, Message::SessionKey(local_key_a.clone())));`
	`308`	`+ assert!(ctx.has_message(peer_a.clone(), Message::SessionKey(local_key_a.clone())));`
`309`	`309`	`assert!(ctx.has_message(peer_a, Message::SessionKey(local_key_b.clone())));`
`310`	`310`	`}`
`311`	`311`
`312`		`- let peer_b = 2;`
	`312`	`+ let peer_b = PeerId::random();`
`313`	`313`
`314`	`314`	`protocol.remove_consensus(&parent_a);`
`315`	`315`
`316`	`316`	`{`
`317`	`317`	`let mut ctx = TestContext::default();`
`318`	`318`
`319`	`319`	`let status = Status { collating_for: None };`
`320`		`- protocol.on_connect(&mut ctx, peer_b, make_status(&status, Roles::AUTHORITY));`
	`320`	`+ protocol.on_connect(&mut ctx, peer_b.clone(), make_status(&status, Roles::AUTHORITY));`
`321`	`321`
`322`		`- assert!(!ctx.has_message(peer_b, Message::SessionKey(local_key_a.clone())));`
	`322`	`+ assert!(!ctx.has_message(peer_b.clone(), Message::SessionKey(local_key_a.clone())));`
`323`	`323`	`assert!(ctx.has_message(peer_b, Message::SessionKey(local_key_b.clone())));`
`324`	`324`	`}`
`325`	`325`	`}`