iplist/iplist_test.go

   1 package iplist
   2
   3 import (
   4         "bufio"
   5         "bytes"
   6         "fmt"
   7         "net"
   8         "strings"
   9         "testing"
  10
  11         "github.com/anacrolix/missinggo"
  12         "github.com/bradfitz/iter"
  13         "github.com/stretchr/testify/assert"
  14         "github.com/stretchr/testify/require"
  15 )
  16
  17 var (
  18         // Note the shared description "eff". The overlapping ranges at 1.2.8.2
  19         // will cause problems. Don't overlap your ranges.
  20         sample = `
  21 # List distributed by iblocklist.com
  22
  23 a:1.2.4.0-1.2.4.255
  24 b:1.2.8.0-1.2.8.255
  25 eff:1.2.8.2-1.2.8.2
  26 something:more detail:86.59.95.195-86.59.95.195
  27 eff:127.0.0.0-127.0.0.1`
  28         packedSample []byte
  29 )
  30
  31 func init() {
  32         var buf bytes.Buffer
  33         list, err := NewFromReader(strings.NewReader(sample))
  34         if err != nil {
  35                 panic(err)
  36         }
  37         err = list.WritePacked(&buf)
  38         if err != nil {
  39                 panic(err)
  40         }
  41         packedSample = buf.Bytes()
  42 }
  43
  44 func TestIPv4RangeLen(t *testing.T) {
  45         ranges, _ := sampleRanges(t)
  46         for i := range iter.N(3) {
  47                 if len(ranges[i].First) != 4 {
  48                         t.FailNow()
  49                 }
  50                 if len(ranges[i].Last) != 4 {
  51                         t.FailNow()
  52                 }
  53         }
  54 }
  55
  56 func sampleRanges(tb testing.TB) (ranges []Range, err error) {
  57         scanner := bufio.NewScanner(strings.NewReader(sample))
  58         for scanner.Scan() {
  59                 r, ok, err := ParseBlocklistP2PLine(scanner.Bytes())
  60                 if err != nil {
  61                         tb.Fatal(err)
  62                 }
  63                 if ok {
  64                         ranges = append(ranges, r)
  65                 }
  66         }
  67         err = scanner.Err()
  68         return
  69 }
  70
  71 func BenchmarkParseP2pBlocklist(b *testing.B) {
  72         for i := 0; i < b.N; i++ {
  73                 sampleRanges(b)
  74         }
  75 }
  76
  77 func connRemoteAddrIP(network, laddr string, dialHost string) net.IP {
  78         l, err := net.Listen(network, laddr)
  79         if err != nil {
  80                 panic(err)
  81         }
  82         go func() {
  83                 c, err := net.Dial(network, net.JoinHostPort(dialHost, fmt.Sprintf("%d", missinggo.AddrPort(l.Addr()))))
  84                 if err != nil {
  85                         panic(err)
  86                 }
  87                 defer c.Close()
  88         }()
  89         c, err := l.Accept()
  90         if err != nil {
  91                 panic(err)
  92         }
  93         defer c.Close()
  94         ret := missinggo.AddrIP(c.RemoteAddr())
  95         return ret
  96 }
  97
  98 func lookupOk(r Range, ok bool) bool {
  99         return ok
 100 }
 101
 102 func TestBadIP(t *testing.T) {
 103         for _, iplist := range []Ranger{
 104                 New(nil),
 105                 NewFromPacked([]byte("\x00\x00\x00\x00\x00\x00\x00\x00")),
 106         } {
 107                 assert.False(t, lookupOk(iplist.Lookup(net.IP(make([]byte, 4)))), "%v", iplist)
 108                 assert.False(t, lookupOk(iplist.Lookup(net.IP(make([]byte, 16)))))
 109                 r, ok := iplist.Lookup(nil)
 110                 assert.True(t, ok)
 111                 assert.Equal(t, r.Description, "bad IP")
 112                 assert.True(t, lookupOk(iplist.Lookup(net.IP(make([]byte, 5)))))
 113         }
 114 }
 115
 116 func testLookuperSimple(t *testing.T, iplist Ranger) {
 117         for _, _case := range []struct {
 118                 IP   string
 119                 Hit  bool
 120                 Desc string
 121         }{
 122                 {"1.2.3.255", false, ""},
 123                 {"1.2.8.0", true, "b"},
 124                 {"1.2.4.255", true, "a"},
 125                 // Try to roll over to the next octet on the parse. Note the final
 126                 // octet is overbounds. In the next case.
 127                 {"1.2.7.256", true, "bad IP"},
 128                 {"1.2.8.1", true, "b"},
 129                 {"1.2.8.2", true, "eff"},
 130         } {
 131                 ip := net.ParseIP(_case.IP)
 132                 r, ok := iplist.Lookup(ip)
 133                 assert.Equal(t, _case.Hit, ok, "%s", _case)
 134                 if !_case.Hit {
 135                         continue
 136                 }
 137                 assert.Equal(t, _case.Desc, r.Description, "%T", iplist)
 138         }
 139 }
 140
 141 func TestSimple(t *testing.T) {
 142         ranges, err := sampleRanges(t)
 143         require.NoError(t, err)
 144         require.Len(t, ranges, 5)
 145         iplist := New(ranges)
 146         testLookuperSimple(t, iplist)
 147         packed := NewFromPacked(packedSample)
 148         testLookuperSimple(t, packed)
 149 }