iplist/iplist_test.go

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