reorg test structure to match tox and CI jobs, drop bumpversion for bump-my-version and move config to pyproject.toml, fix docs building

tests/core/peer/test_addrbook.py

@@ -0,0 +1,61 @@
+import pytest
+
+from libp2p.peer.peerstore import (
+    PeerStore,
+    PeerStoreError,
+)
+
+# Testing methods from IAddrBook base class.
+
+
+def test_addrs_empty():
+    with pytest.raises(PeerStoreError):
+        store = PeerStore()
+        val = store.addrs("peer")
+        assert not val
+
+
+def test_add_addr_single():
+    store = PeerStore()
+    store.add_addr("peer1", "/foo", 10)
+    store.add_addr("peer1", "/bar", 10)
+    store.add_addr("peer2", "/baz", 10)
+
+    assert store.addrs("peer1") == ["/foo", "/bar"]
+    assert store.addrs("peer2") == ["/baz"]
+
+
+def test_add_addrs_multiple():
+    store = PeerStore()
+    store.add_addrs("peer1", ["/foo1", "/bar1"], 10)
+    store.add_addrs("peer2", ["/foo2"], 10)
+
+    assert store.addrs("peer1") == ["/foo1", "/bar1"]
+    assert store.addrs("peer2") == ["/foo2"]
+
+
+def test_clear_addrs():
+    store = PeerStore()
+    store.add_addrs("peer1", ["/foo1", "/bar1"], 10)
+    store.add_addrs("peer2", ["/foo2"], 10)
+    store.clear_addrs("peer1")
+
+    assert store.addrs("peer1") == []
+    assert store.addrs("peer2") == ["/foo2"]
+
+    store.add_addrs("peer1", ["/foo1", "/bar1"], 10)
+
+    assert store.addrs("peer1") == ["/foo1", "/bar1"]
+
+
+def test_peers_with_addrs():
+    store = PeerStore()
+    store.add_addrs("peer1", [], 10)
+    store.add_addrs("peer2", ["/foo"], 10)
+    store.add_addrs("peer3", ["/bar"], 10)
+
+    assert set(store.peers_with_addrs()) == {"peer2", "peer3"}
+
+    store.clear_addrs("peer2")
+
+    assert set(store.peers_with_addrs()) == {"peer3"}

tests/core/peer/test_interop.py

@@ -0,0 +1,47 @@
+import base64
+
+import Crypto.PublicKey.RSA as RSA
+
+from libp2p.crypto.pb import crypto_pb2 as pb
+from libp2p.crypto.rsa import (
+    RSAPrivateKey,
+)
+from libp2p.peer.id import (
+    ID,
+)
+
+# ``PRIVATE_KEY_PROTOBUF_SERIALIZATION`` is a protobuf holding an RSA private key.
+PRIVATE_KEY_PROTOBUF_SERIALIZATION = """
+CAAS4AQwggJcAgEAAoGBAL7w+Wc4VhZhCdM/+Hccg5Nrf4q9NXWwJylbSrXz/unFS24wyk6pEk0zi3W
+7li+vSNVO+NtJQw9qGNAMtQKjVTP+3Vt/jfQRnQM3s6awojtjueEWuLYVt62z7mofOhCtj+VwIdZNBo
+/EkLZ0ETfcvN5LVtLYa8JkXybnOPsLvK+PAgMBAAECgYBdk09HDM7zzL657uHfzfOVrdslrTCj6p5mo
+DzvCxLkkjIzYGnlPuqfNyGjozkpSWgSUc+X+EGLLl3WqEOVdWJtbM61fewEHlRTM5JzScvwrJ39t7o6
+CCAjKA0cBWBd6UWgbN/t53RoWvh9HrA2AW5YrT0ZiAgKe9y7EMUaENVJ8QJBAPhpdmb4ZL4Fkm4OKia
+NEcjzn6mGTlZtef7K/0oRC9+2JkQnCuf6HBpaRhJoCJYg7DW8ZY+AV6xClKrgjBOfERMCQQDExhnzu2
+dsQ9k8QChBlpHO0TRbZBiQfC70oU31kM1AeLseZRmrxv9Yxzdl8D693NNWS2JbKOXl0kMHHcuGQLMVA
+kBZ7WvkmPV3aPL6jnwp2pXepntdVnaTiSxJ1dkXShZ/VSSDNZMYKY306EtHrIu3NZHtXhdyHKcggDXr
+qkBrdgErAkAlpGPojUwemOggr4FD8sLX1ot2hDJyyV7OK2FXfajWEYJyMRL1Gm9Uk1+Un53RAkJneqp
+JGAzKpyttXBTIDO51AkEA98KTiROMnnU8Y6Mgcvr68/SMIsvCYMt9/mtwSBGgl80VaTQ5Hpaktl6Xbh
+VUt5Wv0tRxlXZiViCGCD1EtrrwTw==
+""".replace(
+    "\n", ""
+)
+
+EXPECTED_PEER_ID = "QmRK3JgmVEGiewxWbhpXLJyjWuGuLeSTMTndA1coMHEy5o"
+
+
+# NOTE: this test checks that we can recreate the expected peer id given a private key
+# serialization, taken from the Go implementation of libp2p.
+def test_peer_id_interop():
+    private_key_protobuf_bytes = base64.b64decode(PRIVATE_KEY_PROTOBUF_SERIALIZATION)
+    private_key_protobuf = pb.PrivateKey()
+    private_key_protobuf.ParseFromString(private_key_protobuf_bytes)
+
+    private_key_data = private_key_protobuf.data
+
+    private_key_impl = RSA.import_key(private_key_data)
+    private_key = RSAPrivateKey(private_key_impl)
+    public_key = private_key.get_public_key()
+
+    peer_id = ID.from_pubkey(public_key)
+    assert peer_id == EXPECTED_PEER_ID

tests/core/peer/test_peerid.py

@@ -0,0 +1,110 @@
+import random
+
+import base58
+import multihash
+
+from libp2p.crypto.rsa import (
+    create_new_key_pair,
+)
+import libp2p.peer.id as PeerID
+from libp2p.peer.id import (
+    ID,
+)
+
+ALPHABETS = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+
+# ensure we are not in "debug" mode for the following tests
+PeerID.FRIENDLY_IDS = False
+
+
+def test_eq_impl_for_bytes():
+    random_id_string = ""
+    for _ in range(10):
+        random_id_string += random.choice(ALPHABETS)
+    peer_id = ID(random_id_string.encode())
+    assert peer_id == random_id_string.encode()
+
+
+def test_pretty():
+    random_id_string = ""
+    for _ in range(10):
+        random_id_string += random.choice(ALPHABETS)
+    peer_id = ID(random_id_string.encode())
+    actual = peer_id.pretty()
+    expected = base58.b58encode(random_id_string).decode()
+
+    assert actual == expected
+
+
+def test_str_less_than_10():
+    random_id_string = ""
+    for _ in range(5):
+        random_id_string += random.choice(ALPHABETS)
+    peer_id = base58.b58encode(random_id_string).decode()
+    expected = peer_id
+    actual = ID(random_id_string.encode()).__str__()
+
+    assert actual == expected
+
+
+def test_str_more_than_10():
+    random_id_string = ""
+    for _ in range(10):
+        random_id_string += random.choice(ALPHABETS)
+    peer_id = base58.b58encode(random_id_string).decode()
+    expected = peer_id
+    actual = ID(random_id_string.encode()).__str__()
+
+    assert actual == expected
+
+
+def test_eq_true():
+    random_id_string = ""
+    for _ in range(10):
+        random_id_string += random.choice(ALPHABETS)
+    peer_id = ID(random_id_string.encode())
+
+    assert peer_id == base58.b58encode(random_id_string).decode()
+    assert peer_id == random_id_string.encode()
+    assert peer_id == ID(random_id_string.encode())
+
+
+def test_eq_false():
+    peer_id = ID("efgh")
+    other = ID("abcd")
+
+    assert peer_id != other
+
+
+def test_id_to_base58():
+    random_id_string = ""
+    for _ in range(10):
+        random_id_string += random.choice(ALPHABETS)
+    expected = base58.b58encode(random_id_string).decode()
+    actual = ID(random_id_string.encode()).to_base58()
+
+    assert actual == expected
+
+
+def test_id_from_base58():
+    random_id_string = ""
+    for _ in range(10):
+        random_id_string += random.choice(ALPHABETS)
+    expected = ID(base58.b58decode(random_id_string))
+    actual = ID.from_base58(random_id_string.encode())
+
+    assert actual == expected
+
+
+def test_id_from_public_key():
+    key_pair = create_new_key_pair()
+    public_key = key_pair.public_key
+
+    key_bin = public_key.serialize()
+    algo = multihash.Func.sha2_256
+    mh_digest = multihash.digest(key_bin, algo)
+    expected = ID(mh_digest.encode())
+
+    actual = ID.from_pubkey(public_key)
+
+    assert actual == expected

tests/core/peer/test_peerinfo.py

@@ -0,0 +1,54 @@
+import random
+
+import multiaddr
+import pytest
+
+from libp2p.peer.id import (
+    ID,
+)
+from libp2p.peer.peerinfo import (
+    InvalidAddrError,
+    PeerInfo,
+    info_from_p2p_addr,
+)
+
+ALPHABETS = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+VALID_MULTI_ADDR_STR = "/ip4/127.0.0.1/tcp/8000/p2p/3YgLAeMKSAPcGqZkAt8mREqhQXmJT8SN8VCMN4T6ih4GNX9wvK8mWJnWZ1qA2mLdCQ"  # noqa: E501
+
+
+def test_init_():
+    random_addrs = [random.randint(0, 255) for r in range(4)]
+    random_id_string = ""
+    for _ in range(10):
+        random_id_string += random.SystemRandom().choice(ALPHABETS)
+    peer_id = ID(random_id_string.encode())
+    peer_info = PeerInfo(peer_id, random_addrs)
+
+    assert peer_info.peer_id == peer_id
+    assert peer_info.addrs == random_addrs
+
+
+@pytest.mark.parametrize(
+    "addr",
+    (
+        pytest.param(multiaddr.Multiaddr("/"), id="empty multiaddr"),
+        pytest.param(
+            multiaddr.Multiaddr("/ip4/127.0.0.1"),
+            id="multiaddr without peer_id(p2p protocol)",
+        ),
+    ),
+)
+def test_info_from_p2p_addr_invalid(addr):
+    with pytest.raises(InvalidAddrError):
+        info_from_p2p_addr(addr)
+
+
+def test_info_from_p2p_addr_valid():
+    m_addr = multiaddr.Multiaddr(VALID_MULTI_ADDR_STR)
+    info = info_from_p2p_addr(m_addr)
+    assert (
+        info.peer_id.pretty()
+        == "3YgLAeMKSAPcGqZkAt8mREqhQXmJT8SN8VCMN4T6ih4GNX9wvK8mWJnWZ1qA2mLdCQ"
+    )
+    assert len(info.addrs) == 1
+    assert str(info.addrs[0]) == "/ip4/127.0.0.1/tcp/8000"

tests/core/peer/test_peermetadata.py

@@ -0,0 +1,46 @@
+import pytest
+
+from libp2p.peer.peerstore import (
+    PeerStore,
+    PeerStoreError,
+)
+
+# Testing methods from IPeerMetadata base class.
+
+
+def test_get_empty():
+    with pytest.raises(PeerStoreError):
+        store = PeerStore()
+        val = store.get("peer", "key")
+        assert not val
+
+
+def test_put_get_simple():
+    store = PeerStore()
+    store.put("peer", "key", "val")
+    assert store.get("peer", "key") == "val"
+
+
+def test_put_get_update():
+    store = PeerStore()
+    store.put("peer", "key1", "val1")
+    store.put("peer", "key2", "val2")
+    store.put("peer", "key2", "new val2")
+
+    assert store.get("peer", "key1") == "val1"
+    assert store.get("peer", "key2") == "new val2"
+
+
+def test_put_get_two_peers():
+    store = PeerStore()
+    store.put("peer1", "key1", "val1")
+    store.put("peer2", "key1", "val1 prime")
+
+    assert store.get("peer1", "key1") == "val1"
+    assert store.get("peer2", "key1") == "val1 prime"
+
+    # Try update
+    store.put("peer2", "key1", "new val1")
+
+    assert store.get("peer1", "key1") == "val1"
+    assert store.get("peer2", "key1") == "new val1"

tests/core/peer/test_peerstore.py

@@ -0,0 +1,62 @@
+import pytest
+
+from libp2p.peer.peerstore import (
+    PeerStore,
+    PeerStoreError,
+)
+
+# Testing methods from IPeerStore base class.
+
+
+def test_peer_info_empty():
+    store = PeerStore()
+    with pytest.raises(PeerStoreError):
+        store.peer_info("peer")
+
+
+def test_peer_info_basic():
+    store = PeerStore()
+    store.add_addr("peer", "/foo", 10)
+    info = store.peer_info("peer")
+
+    assert info.peer_id == "peer"
+    assert info.addrs == ["/foo"]
+
+
+def test_add_get_protocols_basic():
+    store = PeerStore()
+    store.add_protocols("peer1", ["p1", "p2"])
+    store.add_protocols("peer2", ["p3"])
+
+    assert set(store.get_protocols("peer1")) == {"p1", "p2"}
+    assert set(store.get_protocols("peer2")) == {"p3"}
+
+
+def test_add_get_protocols_extend():
+    store = PeerStore()
+    store.add_protocols("peer1", ["p1", "p2"])
+    store.add_protocols("peer1", ["p3"])
+
+    assert set(store.get_protocols("peer1")) == {"p1", "p2", "p3"}
+
+
+def test_set_protocols():
+    store = PeerStore()
+    store.add_protocols("peer1", ["p1", "p2"])
+    store.add_protocols("peer2", ["p3"])
+
+    store.set_protocols("peer1", ["p4"])
+    store.set_protocols("peer2", [])
+
+    assert set(store.get_protocols("peer1")) == {"p4"}
+    assert set(store.get_protocols("peer2")) == set()
+
+
+# Test with methods from other Peer interfaces.
+def test_peers():
+    store = PeerStore()
+    store.add_protocols("peer1", [])
+    store.put("peer2", "key", "val")
+    store.add_addr("peer3", "/foo", 10)
+
+    assert set(store.peer_ids()) == {"peer1", "peer2", "peer3"}