iplist/iplist_test.go

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