p2p/addrbook_test.go

   1 package p2p
   2
   3 import (
   4         "fmt"
   5         "io/ioutil"
   6         "math/rand"
   7         "testing"
   8
   9         "github.com/stretchr/testify/assert"
  10         "github.com/tendermint/tmlibs/log"
  11 )
  12
  13 func createTempFileName(prefix string) string {
  14         f, err := ioutil.TempFile("", prefix)
  15         if err != nil {
  16                 panic(err)
  17         }
  18         fname := f.Name()
  19         err = f.Close()
  20         if err != nil {
  21                 panic(err)
  22         }
  23         return fname
  24 }
  25
  26 func TestAddrBookSaveLoad(t *testing.T) {
  27         fname := createTempFileName("addrbook_test")
  28
  29         // 0 addresses
  30         book := NewAddrBook(fname, true)
  31         book.SetLogger(log.TestingLogger())
  32         book.saveToFile(fname)
  33
  34         book = NewAddrBook(fname, true)
  35         book.SetLogger(log.TestingLogger())
  36         book.loadFromFile(fname)
  37
  38         assert.Zero(t, book.Size())
  39
  40         // 100 addresses
  41         randAddrs := randNetAddressPairs(t, 100)
  42
  43         for _, addrSrc := range randAddrs {
  44                 book.AddAddress(addrSrc.addr, addrSrc.src)
  45         }
  46
  47         assert.Equal(t, 100, book.Size())
  48         book.saveToFile(fname)
  49
  50         book = NewAddrBook(fname, true)
  51         book.SetLogger(log.TestingLogger())
  52         book.loadFromFile(fname)
  53
  54         assert.Equal(t, 100, book.Size())
  55 }
  56
  57 func TestAddrBookLookup(t *testing.T) {
  58         fname := createTempFileName("addrbook_test")
  59
  60         randAddrs := randNetAddressPairs(t, 100)
  61
  62         book := NewAddrBook(fname, true)
  63         book.SetLogger(log.TestingLogger())
  64         for _, addrSrc := range randAddrs {
  65                 addr := addrSrc.addr
  66                 src := addrSrc.src
  67                 book.AddAddress(addr, src)
  68
  69                 ka := book.addrLookup[addr.String()]
  70                 assert.NotNil(t, ka, "Expected to find KnownAddress %v but wasn't there.", addr)
  71
  72                 if !(ka.Addr.Equals(addr) && ka.Src.Equals(src)) {
  73                         t.Fatalf("KnownAddress doesn't match addr & src")
  74                 }
  75         }
  76 }
  77
  78 func TestAddrBookPromoteToOld(t *testing.T) {
  79         fname := createTempFileName("addrbook_test")
  80
  81         randAddrs := randNetAddressPairs(t, 100)
  82
  83         book := NewAddrBook(fname, true)
  84         book.SetLogger(log.TestingLogger())
  85         for _, addrSrc := range randAddrs {
  86                 book.AddAddress(addrSrc.addr, addrSrc.src)
  87         }
  88
  89         // Attempt all addresses.
  90         for _, addrSrc := range randAddrs {
  91                 book.MarkAttempt(addrSrc.addr)
  92         }
  93
  94         // Promote half of them
  95         for i, addrSrc := range randAddrs {
  96                 if i%2 == 0 {
  97                         book.MarkGood(addrSrc.addr)
  98                 }
  99         }
 100
 101         // TODO: do more testing :)
 102
 103         selection := book.GetSelection()
 104         t.Logf("selection: %v", selection)
 105
 106         if len(selection) > book.Size() {
 107                 t.Errorf("selection could not be bigger than the book")
 108         }
 109 }
 110
 111 func TestAddrBookHandlesDuplicates(t *testing.T) {
 112         fname := createTempFileName("addrbook_test")
 113
 114         book := NewAddrBook(fname, true)
 115         book.SetLogger(log.TestingLogger())
 116
 117         randAddrs := randNetAddressPairs(t, 100)
 118
 119         differentSrc := randIPv4Address(t)
 120         for _, addrSrc := range randAddrs {
 121                 book.AddAddress(addrSrc.addr, addrSrc.src)
 122                 book.AddAddress(addrSrc.addr, addrSrc.src)  // duplicate
 123                 book.AddAddress(addrSrc.addr, differentSrc) // different src
 124         }
 125
 126         assert.Equal(t, 100, book.Size())
 127 }
 128
 129 type netAddressPair struct {
 130         addr *NetAddress
 131         src  *NetAddress
 132 }
 133
 134 func randNetAddressPairs(t *testing.T, n int) []netAddressPair {
 135         randAddrs := make([]netAddressPair, n)
 136         for i := 0; i < n; i++ {
 137                 randAddrs[i] = netAddressPair{addr: randIPv4Address(t), src: randIPv4Address(t)}
 138         }
 139         return randAddrs
 140 }
 141
 142 func randIPv4Address(t *testing.T) *NetAddress {
 143         for {
 144                 ip := fmt.Sprintf("%v.%v.%v.%v",
 145                         rand.Intn(254)+1,
 146                         rand.Intn(255),
 147                         rand.Intn(255),
 148                         rand.Intn(255),
 149                 )
 150                 port := rand.Intn(65535-1) + 1
 151                 addr, err := NewNetAddressString(fmt.Sprintf("%v:%v", ip, port))
 152                 assert.Nil(t, err, "error generating rand network address")
 153                 if addr.Routable() {
 154                         return addr
 155                 }
 156         }
 157 }
 158
 159 func TestAddrBookRemoveAddress(t *testing.T) {
 160         fname := createTempFileName("addrbook_test")
 161         book := NewAddrBook(fname, true)
 162         book.SetLogger(log.TestingLogger())
 163
 164         addr := randIPv4Address(t)
 165         book.AddAddress(addr, addr)
 166         assert.Equal(t, 1, book.Size())
 167
 168         book.RemoveAddress(addr)
 169         assert.Equal(t, 0, book.Size())
 170
 171         nonExistingAddr := randIPv4Address(t)
 172         book.RemoveAddress(nonExistingAddr)
 173         assert.Equal(t, 0, book.Size())
 174 }