Add tests

net/ip_test.go

@@ -3,18 +3,27 @@ package net
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestAnonymizeIPString(t *testing.T) {
+	_, err := AnonymizeIPString("127.987.475.21")
+	require.Error(t, err)
+
+	_, err = AnonymizeIPString("bbd1:xxxx")
+	require.Error(t, err)
+
+	_, err = AnonymizeIPString("hello-world")
+	require.Error(t, err)
+
 	ipv4 := "192.168.1.42"
 	ipv6 := "bbd1:e95a:adbb:b29a:e38b:577f:6f9a:1fa7"
 
 	anonymizedIPv4, err := AnonymizeIPString(ipv4)
-	assert.Nil(t, err)
+	require.NoError(t, err)
-	assert.Equal(t, "192.168.1.0", anonymizedIPv4)
+	require.Equal(t, "192.168.1.0", anonymizedIPv4)
 
 	anonymizedIPv6, err := AnonymizeIPString(ipv6)
-	assert.Nil(t, err)
+	require.NoError(t, err)
-	assert.Equal(t, "bbd1:e95a:adbb:b29a::", anonymizedIPv6)
+	require.Equal(t, "bbd1:e95a:adbb:b29a::", anonymizedIPv6)
 }

net/iplimit_test.go

@@ -3,57 +3,63 @@ package net
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestIPLimiterNew(t *testing.T) {
 	var err error
 
 	_, err = NewIPLimiter([]string{}, []string{})
-	assert.Nil(t, err)
+	require.Nil(t, err)
 
 	_, err = NewIPLimiter([]string{"::1/128", "127.0.0.1/32", ""}, []string{})
-	assert.Nil(t, err)
+	require.Nil(t, err)
 
 	_, err = NewIPLimiter([]string{}, []string{"::1/128", "127.0.0.1/32", ""})
-	assert.Nil(t, err)
+	require.Nil(t, err)
 }
 
 func TestIPLimiterError(t *testing.T) {
 	var err error
 
 	_, err = NewIPLimiter([]string{}, []string{})
-	assert.Nil(t, err)
+	require.Nil(t, err)
 
 	_, err = NewIPLimiter([]string{"::1"}, []string{})
-	assert.NotNil(t, err, "Should not accept invalid IP")
+	require.NotNil(t, err, "Should not accept invalid IP")
 
 	_, err = NewIPLimiter([]string{}, []string{"::1"})
-	assert.NotNil(t, err, "Should not accept invalid IP")
+	require.NotNil(t, err, "Should not accept invalid IP")
 }
 
 func TestIPLimiterInvalidIPs(t *testing.T) {
 	limiter, _ := NewIPLimiter([]string{}, []string{})
 
-	assert.False(t, limiter.IsAllowed(""), "Invalid IP shouldn't be allowed")
+	require.False(t, limiter.IsAllowed(""), "Invalid IP shouldn't be allowed")
 }
 
 func TestIPLimiterNoIPs(t *testing.T) {
 	limiter, _ := NewIPLimiter([]string{}, []string{})
 
-	assert.True(t, limiter.IsAllowed("127.0.0.1"), "IP should be allowed")
+	require.True(t, limiter.IsAllowed("127.0.0.1"), "IP should be allowed")
 }
 
 func TestIPLimiterAllowlist(t *testing.T) {
 	limiter, _ := NewIPLimiter([]string{}, []string{"::1/128"})
 
-	assert.False(t, limiter.IsAllowed("127.0.0.1"), "Unallowed IP shouldn't be allowed")
+	require.False(t, limiter.IsAllowed("127.0.0.1"), "Unallowed IP shouldn't be allowed")
-	assert.True(t, limiter.IsAllowed("::1"), "Allowed IP should be allowed")
+	require.True(t, limiter.IsAllowed("::1"), "Allowed IP should be allowed")
 }
 
 func TestIPLimiterBlocklist(t *testing.T) {
 	limiter, _ := NewIPLimiter([]string{"::1/128"}, []string{})
 
-	assert.True(t, limiter.IsAllowed("127.0.0.1"), "Allowed IP should be allowed")
+	require.True(t, limiter.IsAllowed("127.0.0.1"), "Allowed IP should be allowed")
-	assert.False(t, limiter.IsAllowed("::1"), "Unallowed IP shouldn't be allowed")
+	require.False(t, limiter.IsAllowed("::1"), "Unallowed IP shouldn't be allowed")
+}
+
+func TestNullIPLimiter(t *testing.T) {
+	limiter := NewNullIPLimiter()
+
+	require.True(t, limiter.IsAllowed("foobar"))
 }

net/port_test.go

@@ -3,19 +3,30 @@ package net
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )
 
 func TestNewPortrange(t *testing.T) {
 	_, err := NewPortrange(1000, 1999)
 
-	assert.Nil(t, err, "Valid port range not accepted: %s", err)
+	require.Nil(t, err, "Valid port range not accepted: %s", err)
 }
 
 func TestInvalidPortrange(t *testing.T) {
 	_, err := NewPortrange(1999, 1000)
 
-	assert.NotNil(t, err, "Invalid port range accepted")
+	require.NotNil(t, err, "Invalid port range accepted")
+}
+
+func TestOutOfRangePortrange(t *testing.T) {
+	p, err := NewPortrange(-1, 70000)
+
+	require.NoError(t, err)
+
+	portrange := p.(*portrange)
+
+	require.Equal(t, 1, portrange.min)
+	require.Equal(t, 65535, len(portrange.ports))
 }
 
 func TestGetPort(t *testing.T) {
@@ -23,26 +34,26 @@ func TestGetPort(t *testing.T) {
 
 	port, err := portrange.Get()
 
-	assert.Nil(t, err)
+	require.Nil(t, err)
-	assert.Equal(t, 1000, port)
+	require.Equal(t, 1000, port)
 }
 
 func TestGetPutPort(t *testing.T) {
 	portrange, _ := NewPortrange(1000, 1999)
 
 	port, err := portrange.Get()
-	assert.Nil(t, err)
+	require.Nil(t, err)
-	assert.Equal(t, 1000, port)
+	require.Equal(t, 1000, port)
 
 	port, err = portrange.Get()
-	assert.Nil(t, err)
+	require.Nil(t, err)
-	assert.Equal(t, 1001, port)
+	require.Equal(t, 1001, port)
 
 	portrange.Put(1000)
 
 	port, err = portrange.Get()
-	assert.Nil(t, err)
+	require.Nil(t, err)
-	assert.Equal(t, 1000, port)
+	require.Equal(t, 1000, port)
 }
 
 func TestPortUnavailable(t *testing.T) {
@@ -50,12 +61,12 @@ func TestPortUnavailable(t *testing.T) {
 
 	for i := 0; i < 1000; i++ {
 		port, _ := portrange.Get()
-		assert.Equal(t, 1000+i, port, "at index %d", i)
+		require.Equal(t, 1000+i, port, "at index %d", i)
 	}
 
 	port, err := portrange.Get()
-	assert.NotNil(t, err)
+	require.NotNil(t, err)
-	assert.Less(t, port, 0)
+	require.Less(t, port, 0)
 }
 
 func TestPutPort(t *testing.T) {
@@ -73,16 +84,27 @@ func TestClampRange(t *testing.T) {
 
 	port, _ := portrange.Get()
 
-	assert.Equal(t, 65000, port)
+	require.Equal(t, 65000, port)
 
 	portrange.Put(65000)
 
 	for i := 65000; i <= 65535; i++ {
 		port, _ := portrange.Get()
-		assert.Equal(t, i, port, "at index %d", i)
+		require.Equal(t, i, port, "at index %d", i)
 	}
 
 	port, _ = portrange.Get()
 
-	assert.Less(t, port, 0)
+	require.Less(t, port, 0)
+}
+
+func TestDummyPortranger(t *testing.T) {
+	portrange := NewDummyPortrange()
+
+	port, err := portrange.Get()
+
+	require.Error(t, err)
+	require.Equal(t, 0, port)
+
+	portrange.Put(42)
 }

net/url/url_test.go

@@ -7,9 +7,20 @@ import (
 )
 
 func TestLookup(t *testing.T) {
-	_, err := Lookup("https://www.google.com")
+	ip, err := Lookup("/localhost:8080/foobar")
 
 	require.NoError(t, err)
+	require.Equal(t, "", ip)
+
+	ip, err = Lookup("http://")
+
+	require.NoError(t, err)
+	require.Equal(t, "", ip)
+
+	ip, err = Lookup("https://www.google.com")
+
+	require.NoError(t, err)
+	require.NotEmpty(t, ip)
 }
 
 func TestLocalhost(t *testing.T) {
@@ -18,3 +29,22 @@ func TestLocalhost(t *testing.T) {
 	require.NoError(t, err)
 	require.Subset(t, []string{"127.0.0.1", "::1"}, []string{ip})
 }
+
+func TestValidate(t *testing.T) {
+	err := Validate("http://localhost/foobar")
+	require.NoError(t, err)
+
+	err = Validate("foobar")
+	require.NoError(t, err)
+}
+
+func TestScheme(t *testing.T) {
+	r := HasScheme("http://localhost/foobar")
+	require.True(t, r)
+
+	r = HasScheme("iueriherfd://localhost/foobar")
+	require.True(t, r)
+
+	r = HasScheme("//localhost/foobar")
+	require.False(t, r)
+}