p2p/addrbook_test.go

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