github.com/anacrolix/torrent@v1.61.0/iplist/iplist_test.go (about)

     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  }