chore: remove noAnnounce from address manager

test/addresses/address-manager.spec.js

@@ -16,7 +16,6 @@ describe('Address Manager', () => {
 
     expect(am.listen.size).to.equal(0)
     expect(am.announce.size).to.equal(0)
-    expect(am.noAnnounce.size).to.equal(0)
   })
 
   it('should return listen multiaddrs on get', () => {
@@ -26,7 +25,6 @@ describe('Address Manager', () => {
 
     expect(am.listen.size).to.equal(listenAddresses.length)
     expect(am.announce.size).to.equal(0)
-    expect(am.noAnnounce.size).to.equal(0)
 
     const listenMultiaddrs = am.getListenAddrs()
     expect(listenMultiaddrs.length).to.equal(2)
@@ -42,28 +40,11 @@ describe('Address Manager', () => {
 
     expect(am.listen.size).to.equal(listenAddresses.length)
     expect(am.announce.size).to.equal(announceAddreses.length)
-    expect(am.noAnnounce.size).to.equal(0)
 
     const announceMultiaddrs = am.getAnnounceAddrs()
     expect(announceMultiaddrs.length).to.equal(1)
     expect(announceMultiaddrs[0].equals(multiaddr(announceAddreses[0]))).to.equal(true)
   })
-
-  it('should return noAnnounce multiaddrs on get', () => {
-    const am = new AddressManager({
-      listen: listenAddresses,
-      noAnnounce: listenAddresses
-    })
-
-    expect(am.listen.size).to.equal(listenAddresses.length)
-    expect(am.announce.size).to.equal(0)
-    expect(am.noAnnounce.size).to.equal(listenAddresses.length)
-
-    const noAnnounceMultiaddrs = am.getNoAnnounceAddrs()
-    expect(noAnnounceMultiaddrs.length).to.equal(2)
-    expect(noAnnounceMultiaddrs[0].equals(multiaddr(listenAddresses[0]))).to.equal(true)
-    expect(noAnnounceMultiaddrs[1].equals(multiaddr(listenAddresses[1]))).to.equal(true)
-  })
 })
 
 describe('libp2p.addressManager', () => {
@@ -76,14 +57,12 @@ describe('libp2p.addressManager', () => {
       config: {
         addresses: {
           listen: listenAddresses,
-          announce: announceAddreses,
-          noAnnounce: listenAddresses
+          announce: announceAddreses
         }
       }
     })
 
     expect(libp2p.addressManager.listen.size).to.equal(listenAddresses.length)
     expect(libp2p.addressManager.announce.size).to.equal(announceAddreses.length)
-    expect(libp2p.addressManager.noAnnounce.size).to.equal(listenAddresses.length)
   })
 })

test/addresses/addresses.node.js

@@ -4,6 +4,7 @@
 const { expect } = require('aegir/utils/chai')
 const sinon = require('sinon')
 
+const multiaddr = require('multiaddr')
 const isLoopback = require('libp2p-utils/src/multiaddr/is-loopback')
 
 const { AddressesOptions } = require('./utils')
@@ -44,8 +45,33 @@ describe('libp2p.multiaddrs', () => {
     expect(listenAddrs.has(listenAddresses[1])).to.equal(true)
   })
 
-  it('should advertise all addresses if noAnnounce addresses are not provided, but with correct ports', async () => {
+  it('should announce transport listen addresses if announce addresses are not provided', async () => {
     [libp2p] = await peerUtils.createPeer({
+      started: false,
+      config: {
+        ...AddressesOptions,
+        addresses: {
+          listen: listenAddresses
+        }
+      }
+    })
+
+    await libp2p.start()
+
+    const tmListen = libp2p.transportManager.getAddrs().map((ma) => ma.toString())
+
+    // Announce 2 listen (transport)
+    const advertiseMultiaddrs = libp2p.multiaddrs.map((ma) => ma.toString())
+    expect(advertiseMultiaddrs.length).to.equal(2)
+    tmListen.forEach((m) => {
+      expect(advertiseMultiaddrs).to.include(m)
+    })
+    expect(advertiseMultiaddrs).to.not.include(listenAddresses[0]) // Random Port switch
+  })
+
+  it('should only announce the given announce addresses when provided', async () => {
+    [libp2p] = await peerUtils.createPeer({
+      started: false,
       config: {
         ...AddressesOptions,
         addresses: {
@@ -55,97 +81,44 @@ describe('libp2p.multiaddrs', () => {
       }
     })
 
+    await libp2p.start()
+
     const tmListen = libp2p.transportManager.getAddrs().map((ma) => ma.toString())
 
-    const spyAnnounce = sinon.spy(libp2p.addressManager, 'getAnnounceAddrs')
-    const spyNoAnnounce = sinon.spy(libp2p.addressManager, 'getNoAnnounceAddrs')
-    const spyListen = sinon.spy(libp2p.addressManager, 'getListenAddrs')
-    const spyTranspMgr = sinon.spy(libp2p.transportManager, 'getAddrs')
-
+    // Announce 1 announce addr
     const advertiseMultiaddrs = libp2p.multiaddrs.map((ma) => ma.toString())
-
-    expect(spyAnnounce).to.have.property('callCount', 1)
-    expect(spyNoAnnounce).to.have.property('callCount', 1)
-    expect(spyListen).to.have.property('callCount', 0) // Listen addr should not be used
-    expect(spyTranspMgr).to.have.property('callCount', 1)
-
-    // Announce 2 listen (transport) + 1 announce
-    expect(advertiseMultiaddrs.length).to.equal(3)
-    tmListen.forEach((m) => {
-      expect(advertiseMultiaddrs).to.include(m)
-    })
-    announceAddreses.forEach((m) => {
-      expect(advertiseMultiaddrs).to.include(m)
-    })
-    expect(advertiseMultiaddrs).to.not.include(listenAddresses[0]) // Random Port switch
-  })
-
-  it('should remove replicated addresses', async () => {
-    [libp2p] = await peerUtils.createPeer({
-      config: {
-        ...AddressesOptions,
-        addresses: {
-          listen: listenAddresses,
-          announce: [listenAddresses[1]]
-        }
-      }
-    })
-
-    const advertiseMultiaddrs = libp2p.multiaddrs.map((ma) => ma.toString())
-
-    // Announce 2 listen (transport), ignoring duplicated in announce
-    expect(advertiseMultiaddrs.length).to.equal(2)
-  })
-
-  it('should not advertise noAnnounce addresses', async () => {
-    const noAnnounce = [listenAddresses[1]]
-    ;[libp2p] = await peerUtils.createPeer({
-      config: {
-        ...AddressesOptions,
-        addresses: {
-          listen: listenAddresses,
-          announce: announceAddreses,
-          noAnnounce
-        }
-      }
-    })
-
-    const advertiseMultiaddrs = libp2p.multiaddrs.map((ma) => ma.toString())
-
-    // Announce 1 listen (transport) not in the noAnnounce and the announce
-    expect(advertiseMultiaddrs.length).to.equal(2)
-
-    announceAddreses.forEach((m) => {
-      expect(advertiseMultiaddrs).to.include(m)
-    })
-    noAnnounce.forEach((m) => {
-      expect(advertiseMultiaddrs).to.not.include(m)
+    expect(advertiseMultiaddrs.length).to.equal(announceAddreses.length)
+    advertiseMultiaddrs.forEach((m) => {
+      expect(tmListen).to.not.include(m)
+      expect(announceAddreses).to.include(m)
     })
   })
 
-  it('can filter out loopback addresses to announced by the announce filter', async () => {
+  it('can filter out loopback addresses by the announce filter', async () => {
     [libp2p] = await peerUtils.createPeer({
       started: false,
       config: {
         ...AddressesOptions,
         addresses: {
           listen: listenAddresses,
-          announce: announceAddreses,
           announceFilter: (multiaddrs) => multiaddrs.filter(m => !isLoopback(m))
         }
       }
     })
 
-    const listenAddrs = libp2p.addressManager.listen
-    expect(listenAddrs.size).to.equal(listenAddresses.length)
-    expect(listenAddrs.has(listenAddresses[0])).to.equal(true)
-    expect(listenAddrs.has(listenAddresses[1])).to.equal(true)
-
     await libp2p.start()
 
+    expect(libp2p.multiaddrs.length).to.equal(0)
+
+    // Stub transportManager addresses to add a public address
+    const stubMa = multiaddr('/ip4/120.220.10.1/tcp/1000')
+    sinon.stub(libp2p.transportManager, 'getAddrs').returns([
+      ...listenAddresses.map((a) => multiaddr(a)),
+      stubMa
+    ])
+
     const multiaddrs = libp2p.multiaddrs
-    expect(multiaddrs.length).to.equal(announceAddreses.length)
-    expect(multiaddrs.includes(listenAddresses[0])).to.equal(false)
-    expect(multiaddrs.includes(listenAddresses[1])).to.equal(false)
+    expect(multiaddrs.length).to.equal(1)
+    expect(multiaddrs[0].equals(stubMa)).to.eql(true)
   })
 })