github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-08-03 09:22:44 +00:00
Code Issues Projects Releases Wiki Activity

Expand IsValidIP unit tests

Browse Source 
Add more test cases, and merge the IsValidIP, IsValidIPv4Address and
IsValidIPv6Address tests together. (Any string that passes IsValidIP
should pass either IsValidIPv4Address or IsValidIPv6Address but not
both, and any string that fails IsValidIP should fail both
IsValidIPv4Address and IsValidIPv6Address.)
This commit is contained in:
Dan Winship 2023-12-27 09:44:45 -05:00
parent 8fc691be94
commit f999b24fad
1 changed files with 165 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

258
staging/src/k8s.io/apimachinery/pkg/util/validation/validation_test.go
View File

@ -323,104 +323,176 @@ func TestIsValidLabelValue(t *testing.T) {
} }
func TestIsValidIP(t *testing.T) { func TestIsValidIP(t *testing.T) {
goodValues := []string{ for _, tc := range []struct {
"::1", name string
"2a00:79e0:2:0:f1c3:e797:93c1:df80", in string
"::", family int
"2001:4860:4860::8888", err string
"::fff:1.1.1.1", }{
"1.1.1.1", // GOOD VALUES
"1.1.1.01", {
"255.0.0.1", name: "ipv4",
"1.0.0.0", in: "1.2.3.4",
"0.0.0.0", family: 4,
} },
for _, val := range goodValues { {
if msgs := IsValidIP(val); len(msgs) != 0 { name: "ipv4, all zeros",
t.Errorf("expected true for %q: %v", val, msgs) in: "0.0.0.0",
} family: 4,
} },
{
name: "ipv4, max",
in: "255.255.255.255",
family: 4,
},
{
name: "ipv6",
in: "1234::abcd",
family: 6,
},
{
name: "ipv6, all zeros, collapsed",
in: "::",
family: 6,
},
{
name: "ipv6, max",
in: "ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff",
family: 6,
},
badValues := []string{ // GOOD, THOUGH NON-CANONICAL, VALUES
"[2001:db8:0:1]:80", {
"myhost.mydomain", name: "ipv6, all zeros, expanded (non-canonical)",
"-1.0.0.0", in: "0:0:0:0:0:0:0:0",
"[2001:db8:0:1]", family: 6,
"a", },
} {
for _, val := range badValues { name: "ipv6, leading 0s (non-canonical)",
if msgs := IsValidIP(val); len(msgs) == 0 { in: "0001:002:03:4::",
t.Errorf("expected false for %q", val) family: 6,
} },
} {
} name: "ipv6, capital letters (non-canonical)",
in: "1234::ABCD",
family: 6,
},
func TestIsValidIPv4Address(t *testing.T) { // BAD VALUES WE CURRENTLY CONSIDER GOOD
goodValues := []string{ {
"1.1.1.1", name: "ipv4 with leading 0s",
"1.1.1.01", in: "1.1.1.01",
"255.0.0.1", family: 4,
"1.0.0.0", },
"0.0.0.0", {
} name: "ipv4-in-ipv6 value",
for _, val := range goodValues { in: "::ffff:1.1.1.1",
if msgs := IsValidIPv4Address(field.NewPath(""), val); len(msgs) != 0 { family: 4,
t.Errorf("expected %q to be valid IPv4 address: %v", val, msgs) },
}
}
badValues := []string{ // BAD VALUES
"[2001:db8:0:1]:80", {
"myhost.mydomain", name: "empty string",
"-1.0.0.0", in: "",
"[2001:db8:0:1]", err: "must be a valid IP address",
"a", },
"2001:4860:4860::8888", {
"::fff:1.1.1.1", name: "junk",
"::1", in: "aaaaaaa",
"2a00:79e0:2:0:f1c3:e797:93c1:df80", err: "must be a valid IP address",
"::", },
} {
for _, val := range badValues { name: "domain name",
if msgs := IsValidIPv4Address(field.NewPath(""), val); len(msgs) == 0 { in: "myhost.mydomain",
t.Errorf("expected %q to be invalid IPv4 address", val) err: "must be a valid IP address",
} },
} {
} name: "cidr",
in: "1.2.3.0/24",
err: "must be a valid IP address",
},
{
name: "ipv4 with out-of-range octets",
in: "1.2.3.400",
err: "must be a valid IP address",
},
{
name: "ipv4 with negative octets",
in: "-1.0.0.0",
err: "must be a valid IP address",
},
{
name: "ipv6 with out-of-range segment",
in: "2001:db8::10005",
err: "must be a valid IP address",
},
{
name: "ipv4:port",
in: "1.2.3.4:80",
err: "must be a valid IP address",
},
{
name: "ipv6 with brackets",
in: "[2001:db8::1]",
err: "must be a valid IP address",
},
{
name: "[ipv6]:port",
in: "[2001:db8::1]:80",
err: "must be a valid IP address",
},
{
name: "host:port",
in: "example.com:80",
err: "must be a valid IP address",
},
{
name: "ipv6 with zone",
in: "1234::abcd%eth0",
err: "must be a valid IP address",
},
{
name: "ipv4 with zone",
in: "169.254.0.0%eth0",
err: "must be a valid IP address",
},
} {
t.Run(tc.name, func(t *testing.T) {
msgs := IsValidIP(tc.in)
if tc.err == "" {
if len(msgs) != 0 {
t.Errorf("expected %q to be valid but got: %v", tc.in, msgs)
}
} else {
if len(msgs) != 1 {
t.Errorf("expected %q to have 1 error but got: %v", tc.in, msgs)
} else if !strings.Contains(msgs[0], tc.err) {
t.Errorf("expected error for %q to contain %q but got: %q", tc.in, tc.err, msgs[0])
}
}
func TestIsValidIPv6Address(t *testing.T) { errs := IsValidIPv4Address(field.NewPath(""), tc.in)
goodValues := []string{ if tc.family == 4 {
"2001:4860:4860::8888", if len(errs) != 0 {
"2a00:79e0:2:0:f1c3:e797:93c1:df80", t.Errorf("expected %q to pass IsValidIPv4Address but got: %v", tc.in, errs)
"2001:0db8:85a3:0000:0000:8a2e:0370:7334", }
"::fff:1.1.1.1", } else {
"::1", if len(errs) == 0 {
"::", t.Errorf("expected %q to fail IsValidIPv4Address", tc.in)
} }
}
for _, val := range goodValues { errs = IsValidIPv6Address(field.NewPath(""), tc.in)
if msgs := IsValidIPv6Address(field.NewPath(""), val); len(msgs) != 0 { if tc.family == 6 {
t.Errorf("expected %q to be valid IPv6 address: %v", val, msgs) if len(errs) != 0 {
} t.Errorf("expected %q to pass IsValidIPv6Address but got: %v", tc.in, errs)
} }
} else {
badValues := []string{ if len(errs) == 0 {
"1.1.1.1", t.Errorf("expected %q to fail IsValidIPv6Address", tc.in)
"1.1.1.01", }
"255.0.0.1", }
"1.0.0.0", })
"0.0.0.0",
"[2001:db8:0:1]:80",
"myhost.mydomain",
"2001:0db8:85a3:0000:0000:8a2e:0370:7334:2001:0db8:85a3:0000:0000:8a2e:0370:7334",
"-1.0.0.0",
"[2001:db8:0:1]",
"a",
}
for _, val := range badValues {
if msgs := IsValidIPv6Address(field.NewPath(""), val); len(msgs) == 0 {
t.Errorf("expected %q to be invalid IPv6 address", val)
}
} }
} }