Merge #373

373: Tidy up some dependencies and tests r=ljedrz a=ljedrz

No functional changes, just quality of life / developer experience ones plus a small dependency update.

As always, the commits describe the specific changes.

Co-authored-by: ljedrz <ljedrz@gmail.com>

Author: bors[bot]

Cargo.lock

@@ -3,40 +3,6 @@
 #![cfg_attr(feature = "nightly", feature(external_doc))]
 #![cfg_attr(feature = "nightly", doc(include = "../README.md"))]
 
-#[macro_use]
-extern crate tracing;
-
-pub use crate::ipld::Ipld;
-use anyhow::{anyhow, format_err};
-pub use bitswap::{BitswapEvent, Block, Stats};
-pub use cid::Cid;
-use cid::Codec;
-use either::Either;
-use futures::channel::mpsc::{channel, Receiver, Sender};
-use futures::channel::oneshot::{channel as oneshot_channel, Sender as OneshotSender};
-use futures::sink::SinkExt;
-use futures::stream::{Fuse, Stream};
-pub use libp2p::core::{
-    connection::ListenerId, multiaddr::Protocol, ConnectedPoint, Multiaddr, PeerId, PublicKey,
-};
-use libp2p::swarm::NetworkBehaviour;
-pub use libp2p::{
-    identity::Keypair,
-    kad::{record::Key, Quorum},
-};
-use std::path::PathBuf;
-use tracing::Span;
-use tracing_futures::Instrument;
-
-use std::borrow::Borrow;
-use std::collections::{HashMap, HashSet};
-use std::fmt;
-use std::future::Future;
-use std::ops::Range;
-use std::pin::Pin;
-use std::sync::{atomic::Ordering, Arc};
-use std::task::{Context, Poll};
-
 mod config;
 pub mod dag;
 pub mod error;
@@ -50,17 +16,66 @@ pub mod repo;
 mod subscription;
 pub mod unixfs;
 
-use self::dag::IpldDag;
-pub use self::error::Error;
-use self::ipns::Ipns;
-use self::p2p::addr::{could_be_bound_from_ephemeral, starts_unspecified};
-pub use self::p2p::pubsub::{PubsubMessage, SubscriptionStream};
-use self::p2p::{create_swarm, SwarmOptions, TSwarm};
-pub use self::p2p::{Connection, KadResult, MultiaddrWithPeerId, MultiaddrWithoutPeerId};
-pub use self::path::IpfsPath;
-use self::repo::{create_repo, Repo, RepoEvent, RepoOptions};
-pub use self::repo::{PinKind, PinMode, RepoTypes};
-use self::subscription::SubscriptionFuture;
+#[macro_use]
+extern crate tracing;
+
+use anyhow::{anyhow, format_err};
+use cid::Codec;
+use either::Either;
+use futures::{
+    channel::{
+        mpsc::{channel, Receiver, Sender},
+        oneshot::{channel as oneshot_channel, Sender as OneshotSender},
+    },
+    sink::SinkExt,
+    stream::{Fuse, Stream},
+};
+use libp2p::swarm::NetworkBehaviour;
+use tracing::Span;
+use tracing_futures::Instrument;
+
+use std::{
+    borrow::Borrow,
+    collections::{HashMap, HashSet},
+    env, fmt,
+    future::Future,
+    ops::{Deref, DerefMut, Range},
+    path::PathBuf,
+    pin::Pin,
+    sync::{atomic::Ordering, Arc},
+    task::{Context, Poll},
+};
+
+use self::{
+    dag::IpldDag,
+    ipns::Ipns,
+    p2p::{
+        addr::{could_be_bound_from_ephemeral, starts_unspecified},
+        create_swarm, SwarmOptions, TSwarm,
+    },
+    repo::{create_repo, Repo, RepoEvent, RepoOptions},
+    subscription::SubscriptionFuture,
+};
+
+pub use self::{
+    error::Error,
+    ipld::Ipld,
+    p2p::{
+        pubsub::{PubsubMessage, SubscriptionStream},
+        Connection, KadResult, MultiaddrWithPeerId, MultiaddrWithoutPeerId,
+    },
+    path::IpfsPath,
+    repo::{PinKind, PinMode, RepoTypes},
+};
+pub use bitswap::{BitswapEvent, Block, Stats};
+pub use cid::Cid;
+pub use libp2p::{
+    core::{
+        connection::ListenerId, multiaddr::Protocol, ConnectedPoint, Multiaddr, PeerId, PublicKey,
+    },
+    identity::Keypair,
+    kad::{record::Key, Quorum},
+};
 
 /// All types can be changed at compile time by implementing
 /// `IpfsTypes`.
@@ -119,7 +134,7 @@ impl IpfsOptions {
     /// Creates an inmemory store backed node for tests
     pub fn inmemory_with_generated_keys() -> Self {
         Self {
-            ipfs_path: std::env::temp_dir(),
+            ipfs_path: env::temp_dir(),
             keypair: Keypair::generate_ed25519(),
             mdns: Default::default(),
             bootstrap: Default::default(),
@@ -194,13 +209,13 @@ impl Default for IpfsOptions {
             );
         }
 
-        let ipfs_path = if let Ok(path) = std::env::var("IPFS_PATH") {
+        let ipfs_path = if let Ok(path) = env::var("IPFS_PATH") {
             PathBuf::from(path)
         } else {
             let root = if let Some(home) = dirs::home_dir() {
                 home
             } else {
-                std::env::current_dir().unwrap()
+                env::current_dir().unwrap()
             };
             root.join(".rust-ipfs")
         };
@@ -383,7 +398,7 @@ impl<Types: IpfsTypes> UninitializedIpfs<Types> {
     }
 }
 
-impl<Types: IpfsTypes> std::ops::Deref for Ipfs<Types> {
+impl<Types: IpfsTypes> Deref for Ipfs<Types> {
     type Target = IpfsInner<Types>;
 
     fn deref(&self) -> &Self::Target {
@@ -1676,16 +1691,16 @@ mod node {
         }
     }
 
-    impl std::ops::Deref for Node {
+    impl Deref for Node {
         type Target = Ipfs<TestTypes>;
 
         fn deref(&self) -> &Self::Target {
             &self.ipfs
         }
     }
 
-    impl std::ops::DerefMut for Node {
-        fn deref_mut(&mut self) -> &mut <Self as std::ops::Deref>::Target {
+    impl DerefMut for Node {
+        fn deref_mut(&mut self) -> &mut <Self as Deref>::Target {
             &mut self.ipfs
         }
     }

src/lib.rs

@@ -5,13 +5,13 @@ use std::time::Duration;
 use tokio::time;
 
 mod common;
-use common::{spawn_connected_nodes, Topology};
+use common::{spawn_nodes, Topology};
 
 // Ensure that the Bitswap object doesn't leak.
 #[tokio::test(max_threads = 1)]
 async fn check_bitswap_cleanups() {
     // create a few nodes and connect the first one to others
-    let mut nodes = spawn_connected_nodes(3, Topology::Star).await;
+    let mut nodes = spawn_nodes(3, Topology::Star).await;
 
     let bitswap_peers = nodes[0].get_bitswap_peers().await.unwrap();
     assert_eq!(bitswap_peers.len(), 2);
@@ -52,7 +52,7 @@ async fn bitswap_stress_test() {
     let data = b"hello block\n".to_vec().into_boxed_slice();
     let cid = Cid::new_v1(Codec::Raw, Sha2_256::digest(&data));
 
-    let nodes = spawn_connected_nodes(5, Topology::Mesh).await;
+    let nodes = spawn_nodes(5, Topology::Mesh).await;
 
     for (i, node) in nodes.iter().enumerate() {
         if filter(i) {

tests/bitswap.rs

@@ -2,10 +2,12 @@ pub mod interop;
 
 use ipfs::Node;
 
-/// The way in which nodes are connected to each other; to be used with spawn_connected_nodes.
+/// The way in which nodes are connected to each other; to be used with spawn_nodes.
 #[allow(dead_code)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Topology {
+    /// no connections
+    None,
     /// a > b > c
     Line,
     /// a > b > c > a
@@ -17,7 +19,7 @@ pub enum Topology {
 }
 
 #[allow(dead_code)]
-pub async fn spawn_connected_nodes(count: usize, topology: Topology) -> Vec<Node> {
+pub async fn spawn_nodes(count: usize, topology: Topology) -> Vec<Node> {
     let mut nodes = Vec::with_capacity(count);
 
     for i in 0..count {
@@ -54,6 +56,7 @@ pub async fn spawn_connected_nodes(count: usize, topology: Topology) -> Vec<Node
                 nodes[0].connect(node.addrs[0].clone()).await.unwrap();
             }
         }
+        Topology::None => {}
     }
 
     nodes

tests/common/mod.rs

@@ -5,7 +5,7 @@ use std::time::Duration;
 use tokio::time::timeout;
 
 mod common;
-use common::{spawn_connected_nodes, Topology};
+use common::{spawn_nodes, Topology};
 
 #[tokio::test(max_threads = 1)]
 async fn exchange_block() {
@@ -14,7 +14,7 @@ async fn exchange_block() {
     let data = b"hello block\n".to_vec().into_boxed_slice();
     let cid = Cid::new_v1(Codec::Raw, Sha2_256::digest(&data));
 
-    let nodes = spawn_connected_nodes(2, Topology::Line).await;
+    let nodes = spawn_nodes(2, Topology::Line).await;
 
     nodes[0]
         .put_block(Block {