maze/styx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial import

Browse Source
This commit is contained in:
maze
2025-09-26 08:49:53 +02:00
commit a76650da35
35 changed files with 4660 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

410
internal/netutil/network_test.go Normal file
View File

@@ -0,0 +1,410 @@
package netutil
import (
"net"
"testing"
)
func TestNewNetworkTree(t *testing.T) {
// Test empty creation
nl, err := NewNetworkTree()
if err != nil {
t.Fatalf("NewNetworkTree() failed: %v", err)
}
if nl == nil {
t.Fatal("NewNetworkTree() returned nil")
}
if nl.ranger == nil {
t.Error("NetworkTree ranger should not be nil")
}
// Test creation with networks
nl, err = NewNetworkTree("192.168.1.0/24", "10.0.0.0/8")
if err != nil {
t.Fatalf("NewNetworkTree() with networks failed: %v", err)
}
if nl == nil {
t.Fatal("NewNetworkTree() with networks returned nil")
}
}
func TestNewNetworkTree_InvalidNetworks(t *testing.T) {
// Test with invalid network
_, err := NewNetworkTree("invalid-cidr")
if err == nil {
t.Error("NewNetworkTree() with invalid CIDR should have failed")
}
// Test with mix of valid and invalid networks
_, err = NewNetworkTree("192.168.1.0/24", "invalid-cidr", "10.0.0.0/8")
if err == nil {
t.Error("NewNetworkTree() with mixed valid/invalid CIDRs should have failed")
}
}
func TestNetworkTree_AddCIDR_Valid(t *testing.T) {
nl, err := NewNetworkTree()
if err != nil {
t.Fatalf("NewNetworkTree() failed: %v", err)
}
tests := []struct {
cidr string
desc string
}{
{"192.168.1.0/24", "IPv4 CIDR"},
{"10.0.0.0/8", "IPv4 large range"},
{"2001:db8::/32", "IPv6 CIDR"},
{"::1/128", "IPv6 localhost"},
{"0.0.0.0/0", "IPv4 entire internet"},
{"::/0", "IPv6 entire internet"},
}
for _, tt := range tests {
t.Run(tt.desc, func(t *testing.T) {
if err := nl.AddCIDR(tt.cidr); err != nil {
t.Errorf("AddCIDR(%q) failed: %v", tt.cidr, err)
}
})
}
}
func TestNetworkTree_AddCIDR_Invalid(t *testing.T) {
nl, err := NewNetworkTree()
if err != nil {
t.Fatalf("NewNetworkTree() failed: %v", err)
}
invalidCIDRs := []string{
"invalid-cidr",
"192.168.1.1", // missing mask
"192.168.1.0/33", // invalid mask for IPv4
"2001:db8::/129", // invalid mask for IPv6
"",
"not-an-ip/24",
}
for _, cidr := range invalidCIDRs {
t.Run(cidr, func(t *testing.T) {
if err := nl.AddCIDR(cidr); err == nil {
t.Errorf("AddCIDR(%q) should have failed but didn't", cidr)
}
})
}
}
func TestNetworkTree_Add(t *testing.T) {
nl, err := NewNetworkTree()
if err != nil {
t.Fatalf("NewNetworkTree() failed: %v", err)
}
tests := []struct {
cidr string
desc string
}{
{"192.168.1.0/24", "IPv4 network"},
{"2001:db8::/32", "IPv6 network"},
}
for _, tt := range tests {
t.Run(tt.desc, func(t *testing.T) {
_, ipNet, err := net.ParseCIDR(tt.cidr)
if err != nil {
t.Fatalf("ParseCIDR failed: %v", err)
}
// Should not panic
nl.Add(ipNet)
})
}
}
func TestNetworkTree_Contains_IPv4(t *testing.T) {
nl, err := NewNetworkTree("192.168.1.0/24", "10.0.0.0/8", "172.16.0.0/12")
if err != nil {
t.Fatalf("NewNetworkTree() failed: %v", err)
}
tests := []struct {
ip string
want bool
desc string
}{
// IPs that should match
{"192.168.1.1", true, "in 192.168.1.0/24"},
{"192.168.1.255", true, "broadcast in 192.168.1.0/24"},
{"10.0.0.1", true, "in 10.0.0.0/8"},
{"10.255.255.255", true, "max in 10.0.0.0/8"},
{"172.16.0.1", true, "in 172.16.0.0/12"},
{"172.31.255.255", true, "max in 172.16.0.0/12"},
// IPs that should not match
{"192.168.2.1", false, "outside 192.168.1.0/24"},
{"11.0.0.1", false, "outside 10.0.0.0/8"},
{"172.32.0.1", false, "outside 172.16.0.0/12"},
{"8.8.8.8", false, "public DNS"},
}
for _, tt := range tests {
t.Run(tt.desc, func(t *testing.T) {
ip := net.ParseIP(tt.ip)
if ip == nil {
t.Fatalf("ParseIP(%q) returned nil", tt.ip)
}
got := nl.Contains(ip)
if got != tt.want {
t.Errorf("Contains(%q) = %v, want %v", tt.ip, got, tt.want)
}
})
}
}
func TestNetworkTree_Contains_IPv6(t *testing.T) {
nl, err := NewNetworkTree("2001:db8::/32", "2001:db8:abcd::/48", "::1/128")
if err != nil {
t.Fatalf("NewNetworkTree() failed: %v", err)
}
tests := []struct {
ip string
want bool
desc string
}{
// IPs that should match
{"2001:db8::1", true, "in 2001:db8::/32"},
{"2001:db8:ffff:ffff:ffff:ffff:ffff:ffff", true, "max in 2001:db8::/32"},
{"2001:db8:abcd::1", true, "in 2001:db8:abcd::/48"},
{"::1", true, "localhost"},
// IPs that should not match
{"2001:db9::1", false, "outside 2001:db8::/32"},
{"2001:db9:abcd::1", false, "outside 2001:db8:abcd::/48"},
{"::2", false, "outside ::1/128"},
{"2001:4860:4860::8888", false, "public DNS"},
}
for _, tt := range tests {
t.Run(tt.desc, func(t *testing.T) {
ip := net.ParseIP(tt.ip)
if ip == nil {
t.Fatalf("ParseIP(%q) returned nil", tt.ip)
}
got := nl.Contains(ip)
if got != tt.want {
t.Errorf("Contains(%q) = %v, want %v", tt.ip, got, tt.want)
}
})
}
}
func TestNetworkTree_Contains_EdgeCases(t *testing.T) {
nl, err := NewNetworkTree()
if err != nil {
t.Fatalf("NewNetworkTree() failed: %v", err)
}
// Test with nil IP
if nl.Contains(nil) != false {
t.Error("Contains(nil) should return false")
}
// Test with empty list
ip := net.ParseIP("192.168.1.1")
if nl.Contains(ip) != false {
t.Error("Contains() on empty list should return false")
}
}
func TestNetworkTree_Contains_OverlappingRanges(t *testing.T) {
nl, err := NewNetworkTree("192.168.0.0/16", "192.168.1.0/24", "192.168.1.128/25")
if err != nil {
t.Fatalf("NewNetworkTree() failed: %v", err)
}
// All these should match because we have overlapping ranges
tests := []string{
"192.168.1.1",
"192.168.1.129",
"192.168.2.1",
}
for _, ipStr := range tests {
t.Run(ipStr, func(t *testing.T) {
ip := net.ParseIP(ipStr)
if !nl.Contains(ip) {
t.Errorf("Contains(%q) should return true for overlapping ranges", ipStr)
}
})
}
}
func TestNetworkTree_Contains_EntireInternet(t *testing.T) {
nl, err := NewNetworkTree("0.0.0.0/0", "::/0")
if err != nil {
t.Fatalf("NewNetworkTree() failed: %v", err)
}
tests := []struct {
ip string
desc string
}{
{"192.168.1.1", "IPv4 private"},
{"8.8.8.8", "IPv4 public"},
{"2001:db8::1", "IPv6"},
{"::1", "IPv6 localhost"},
}
for _, tt := range tests {
t.Run(tt.desc, func(t *testing.T) {
ip := net.ParseIP(tt.ip)
if !nl.Contains(ip) {
t.Errorf("Contains(%q) should return true for entire internet range", tt.ip)
}
})
}
}
func TestNetworkTree_MixedIPv4AndIPv6(t *testing.T) {
nl, err := NewNetworkTree("192.168.1.0/24", "2001:db8::/32")
if err != nil {
t.Fatalf("NewNetworkTree() failed: %v", err)
}
// Test IPv4 in IPv6 format (should still work due to normalization)
ipv4InIPv6 := net.ParseIP("::ffff:192.168.1.1") // IPv4-mapped IPv6
if !nl.Contains(ipv4InIPv6) {
t.Error("Contains() should handle IPv4-mapped IPv6 addresses")
}
// Regular IPv4 should work
ipv4 := net.ParseIP("192.168.1.1")
if !nl.Contains(ipv4) {
t.Error("Contains() should handle regular IPv4 addresses")
}
// IPv6 should work
ipv6 := net.ParseIP("2001:db8::1")
if !nl.Contains(ipv6) {
t.Error("Contains() should handle IPv6 addresses")
}
}
func TestNetworkTree_Add_InvalidIPNet(t *testing.T) {
nl, err := NewNetworkTree()
if err != nil {
t.Fatalf("NewNetworkTree() failed: %v", err)
}
// Create an invalid IPNet (nil IP)
invalidIPNet := &net.IPNet{
IP: nil,
Mask: net.CIDRMask(24, 32),
}
// This should not panic
nl.Add(invalidIPNet)
// Verify that it doesn't affect Contains results
ip := net.ParseIP("192.168.1.1")
if nl.Contains(ip) {
t.Error("Contains() should return false after adding invalid IPNet")
}
}
func TestNetworkTree_InitializationWithNetworks(t *testing.T) {
networks := []string{
"10.0.0.0/8",
"172.16.0.0/12",
"192.168.0.0/16",
"2001:db8::/32",
}
nl, err := NewNetworkTree(networks...)
if err != nil {
t.Fatalf("NewNetworkTree() with multiple networks failed: %v", err)
}
// Test that all networks were added correctly
testCases := []struct {
ip string
want bool
}{
{"10.1.2.3", true},
{"172.16.1.1", true},
{"192.168.1.1", true},
{"2001:db8::1", true},
{"8.8.8.8", false},
}
for _, tc := range testCases {
ip := net.ParseIP(tc.ip)
if got := nl.Contains(ip); got != tc.want {
t.Errorf("Contains(%q) = %v, want %v", tc.ip, got, tc.want)
}
}
}
func BenchmarkNetworkTree_Contains(b *testing.B) {
nl, err := NewNetworkTree(
"10.0.0.0/8",
"172.16.0.0/12",
"192.168.0.0/16",
"2001:db8::/32",
)
if err != nil {
b.Fatalf("NewNetworkTree() failed: %v", err)
}
testIPs := []net.IP{
net.ParseIP("10.1.2.3"),
net.ParseIP("192.168.1.1"),
net.ParseIP("2001:db8::1"),
net.ParseIP("8.8.8.8"),
}
b.ResetTimer()
for i := 0; i < b.N; i++ {
ip := testIPs[i%len(testIPs)]
nl.Contains(ip)
}
}
func BenchmarkNetworkTree_NewNetworkTree(b *testing.B) {
cidrs := []string{
"10.0.0.0/8",
"172.16.0.0/12",
"192.168.0.0/16",
"2001:db8::/32",
}
b.ResetTimer()
for b.Loop() {
_, err := NewNetworkTree(cidrs...)
if err != nil {
b.Fatalf("NewNetworkTree() failed: %v", err)
}
}
}
func BenchmarkNetworkTree_AddCIDR(b *testing.B) {
cidrs := []string{
"10.0.0.0/8",
"172.16.0.0/12",
"192.168.0.0/16",
"2001:db8::/32",
}
b.ResetTimer()
for b.Loop() {
nl, err := NewNetworkTree()
if err != nil {
b.Fatalf("NewNetworkTree() failed: %v", err)
}
for _, cidr := range cidrs {
nl.AddCIDR(cidr)
}
}
}