github/kubernetes
1
0
Fork 0
mirror of https://github.com/k3s-io/kubernetes.git synced 2025-07-21 10:51:29 +00:00
Code Issues Projects Releases Wiki Activity

Merge pull request #114784 from TommyStarK/pkg-apis/replace-deprecated-pointer-function

Browse Source 
pkg/apis: Replace deprecated pointer function
This commit is contained in:
Kubernetes Prow Robot 2023-01-05 11:08:09 -08:00 committed by GitHub
commit e119680318
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 262 additions and 262 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

292
pkg/apis/core/validation/validation_test.go
View File

File diff suppressed because it is too large Load Diff

16
pkg/apis/discovery/v1beta1/conversion_test.go
View File

@ -63,7 +63,7 @@ func TestEndpointZoneConverstion(t *testing.T) {
DeprecatedTopology: map[string]string{ DeprecatedTopology: map[string]string{
"key1": "val1", "key1": "val1",
}, },
Zone: utilpointer.StringPtr("zone1"), Zone: utilpointer.String("zone1"),
}, },
}, },
{ {
@ -74,19 +74,19 @@ func TestEndpointZoneConverstion(t *testing.T) {
}, },
}, },
internal: discovery.Endpoint{ internal: discovery.Endpoint{
Zone: utilpointer.StringPtr("zone1"), Zone: utilpointer.String("zone1"),
}, },
}, },
{ {
desc: "nodeName and topology[hostname] are populated with different values", desc: "nodeName and topology[hostname] are populated with different values",
external: v1beta1.Endpoint{ external: v1beta1.Endpoint{
NodeName: utilpointer.StringPtr("node-1"), NodeName: utilpointer.String("node-1"),
Topology: map[string]string{ Topology: map[string]string{
corev1.LabelHostname: "node-2", corev1.LabelHostname: "node-2",
}, },
}, },
internal: discovery.Endpoint{ internal: discovery.Endpoint{
NodeName: utilpointer.StringPtr("node-1"), NodeName: utilpointer.String("node-1"),
DeprecatedTopology: map[string]string{ DeprecatedTopology: map[string]string{
corev1.LabelHostname: "node-2", corev1.LabelHostname: "node-2",
}, },
@ -95,13 +95,13 @@ func TestEndpointZoneConverstion(t *testing.T) {
{ {
desc: "nodeName and topology[hostname] are populated with same values", desc: "nodeName and topology[hostname] are populated with same values",
external: v1beta1.Endpoint{ external: v1beta1.Endpoint{
NodeName: utilpointer.StringPtr("node-1"), NodeName: utilpointer.String("node-1"),
Topology: map[string]string{ Topology: map[string]string{
corev1.LabelHostname: "node-1", corev1.LabelHostname: "node-1",
}, },
}, },
internal: discovery.Endpoint{ internal: discovery.Endpoint{
NodeName: utilpointer.StringPtr("node-1"), NodeName: utilpointer.String("node-1"),
}, },
}, },
{ {
@ -120,13 +120,13 @@ func TestEndpointZoneConverstion(t *testing.T) {
{ {
desc: "only nodeName is populated", desc: "only nodeName is populated",
external: v1beta1.Endpoint{ external: v1beta1.Endpoint{
NodeName: utilpointer.StringPtr("node-1"), NodeName: utilpointer.String("node-1"),
Topology: map[string]string{ Topology: map[string]string{
corev1.LabelHostname: "node-1", corev1.LabelHostname: "node-1",
}, },
}, },
internal: discovery.Endpoint{ internal: discovery.Endpoint{
NodeName: utilpointer.StringPtr("node-1"), NodeName: utilpointer.String("node-1"),
}, },
}, },
} }

142
pkg/apis/discovery/validation/validation_test.go
View File

@ -44,12 +44,12 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: generateIPAddresses(1), Addresses: generateIPAddresses(1),
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -59,12 +59,12 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv6, AddressType: discovery.AddressTypeIPv6,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: []string{"a00:100::4"}, Addresses: []string{"a00:100::4"},
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -74,12 +74,12 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeFQDN, AddressType: discovery.AddressTypeFQDN,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: []string{"foo.example.com", "example.com", "example.com.", "hyphens-are-good.example.com"}, Addresses: []string{"foo.example.com", "example.com", "example.com.", "hyphens-are-good.example.com"},
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -89,18 +89,18 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("tcp"), Name: utilpointer.String("tcp"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}, { }, {
Name: utilpointer.StringPtr("udp"), Name: utilpointer.String("udp"),
Protocol: protocolPtr(api.ProtocolUDP), Protocol: protocolPtr(api.ProtocolUDP),
}, { }, {
Name: utilpointer.StringPtr("sctp"), Name: utilpointer.String("sctp"),
Protocol: protocolPtr(api.ProtocolSCTP), Protocol: protocolPtr(api.ProtocolSCTP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: generateIPAddresses(1), Addresses: generateIPAddresses(1),
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -110,25 +110,25 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("one"), Name: utilpointer.String("one"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
AppProtocol: utilpointer.StringPtr("HTTP"), AppProtocol: utilpointer.String("HTTP"),
}, { }, {
Name: utilpointer.StringPtr("two"), Name: utilpointer.String("two"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
AppProtocol: utilpointer.StringPtr("https"), AppProtocol: utilpointer.String("https"),
}, { }, {
Name: utilpointer.StringPtr("three"), Name: utilpointer.String("three"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
AppProtocol: utilpointer.StringPtr("my-protocol"), AppProtocol: utilpointer.String("my-protocol"),
}, { }, {
Name: utilpointer.StringPtr("four"), Name: utilpointer.String("four"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
AppProtocol: utilpointer.StringPtr("example.com/custom-protocol"), AppProtocol: utilpointer.String("example.com/custom-protocol"),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: generateIPAddresses(1), Addresses: generateIPAddresses(1),
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -138,10 +138,10 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr(""), Name: utilpointer.String(""),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}, { }, {
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -155,7 +155,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr(strings.Repeat("a", 63)), Name: utilpointer.String(strings.Repeat("a", 63)),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -195,7 +195,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -209,7 +209,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -224,7 +224,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -243,10 +243,10 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr(""), Name: utilpointer.String(""),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}, { }, {
Name: utilpointer.StringPtr(""), Name: utilpointer.String(""),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{}, Endpoints: []discovery.Endpoint{},
@ -258,7 +258,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("aCapital"), Name: utilpointer.String("aCapital"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{}, Endpoints: []discovery.Endpoint{},
@ -270,7 +270,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("almost_valid"), Name: utilpointer.String("almost_valid"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{}, Endpoints: []discovery.Endpoint{},
@ -282,7 +282,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr(strings.Repeat("a", 64)), Name: utilpointer.String(strings.Repeat("a", 64)),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{}, Endpoints: []discovery.Endpoint{},
@ -294,7 +294,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.Protocol("foo")), Protocol: protocolPtr(api.Protocol("foo")),
}}, }},
}, },
@ -322,7 +322,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -336,7 +336,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -350,7 +350,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -365,7 +365,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -380,12 +380,12 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: generateIPAddresses(1), Addresses: generateIPAddresses(1),
Hostname: utilpointer.StringPtr("--INVALID"), Hostname: utilpointer.String("--INVALID"),
}}, }},
}, },
}, },
@ -398,12 +398,12 @@ func TestValidateEndpointSlice(t *testing.T) {
}, },
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: generateIPAddresses(1), Addresses: generateIPAddresses(1),
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -413,12 +413,12 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: []string{"123.456.789.012"}, Addresses: []string{"123.456.789.012"},
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -428,12 +428,12 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: []string{"123.456.789.012", "2001:4860:4860::8888"}, Addresses: []string{"123.456.789.012", "2001:4860:4860::8888"},
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -443,12 +443,12 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv6, AddressType: discovery.AddressTypeIPv6,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: []string{"123.456.789.012", "2001:4860:4860:defg"}, Addresses: []string{"123.456.789.012", "2001:4860:4860:defg"},
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -458,12 +458,12 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeFQDN, AddressType: discovery.AddressTypeFQDN,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: []string{"foo.*", "FOO.example.com", "underscores_are_bad.example.com", "*.example.com"}, Addresses: []string{"foo.*", "FOO.example.com", "underscores_are_bad.example.com", "*.example.com"},
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -473,13 +473,13 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
AppProtocol: utilpointer.StringPtr("--"), AppProtocol: utilpointer.String("--"),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: generateIPAddresses(1), Addresses: generateIPAddresses(1),
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -489,7 +489,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -506,7 +506,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -527,7 +527,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -558,7 +558,7 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -573,12 +573,12 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: []string{"127.0.0.1"}, Addresses: []string{"127.0.0.1"},
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -588,12 +588,12 @@ func TestValidateEndpointSlice(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv6, AddressType: discovery.AddressTypeIPv6,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: []string{"fe80::9656:d028:8652:66b6"}, Addresses: []string{"fe80::9656:d028:8652:66b6"},
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -626,12 +626,12 @@ func TestValidateEndpointSliceCreate(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: generateIPAddresses(1), Addresses: generateIPAddresses(1),
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
}}, }},
}, },
}, },
@ -641,13 +641,13 @@ func TestValidateEndpointSliceCreate(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: generateIPAddresses(1), Addresses: generateIPAddresses(1),
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
NodeName: utilpointer.StringPtr("valid-node-name"), NodeName: utilpointer.String("valid-node-name"),
}}, }},
}, },
}, },
@ -659,13 +659,13 @@ func TestValidateEndpointSliceCreate(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: generateIPAddresses(1), Addresses: generateIPAddresses(1),
Hostname: utilpointer.StringPtr("valid-123"), Hostname: utilpointer.String("valid-123"),
NodeName: utilpointer.StringPtr("INvalid-node-name"), NodeName: utilpointer.String("INvalid-node-name"),
}}, }},
}, },
}, },
@ -675,7 +675,7 @@ func TestValidateEndpointSliceCreate(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressType("IP"), AddressType: discovery.AddressType("IP"),
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -689,7 +689,7 @@ func TestValidateEndpointSliceCreate(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressType("other"), AddressType: discovery.AddressType("other"),
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr("http"), Name: utilpointer.String("http"),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}}, }},
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
@ -744,7 +744,7 @@ func TestValidateEndpointSliceUpdate(t *testing.T) {
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Endpoints: []discovery.Endpoint{{ Endpoints: []discovery.Endpoint{{
Addresses: []string{"10.1.2.3"}, Addresses: []string{"10.1.2.3"},
NodeName: utilpointer.StringPtr("INVALID foo"), NodeName: utilpointer.String("INVALID foo"),
}}, }},
}, },
expectedErrors: 1, expectedErrors: 1,
@ -781,7 +781,7 @@ func TestValidateEndpointSliceUpdate(t *testing.T) {
ObjectMeta: standardMeta, ObjectMeta: standardMeta,
AddressType: discovery.AddressTypeIPv4, AddressType: discovery.AddressTypeIPv4,
Ports: []discovery.EndpointPort{{ Ports: []discovery.EndpointPort{{
Name: utilpointer.StringPtr(""), Name: utilpointer.String(""),
Protocol: protocolPtr(api.Protocol("invalid")), Protocol: protocolPtr(api.Protocol("invalid")),
}}, }},
}, },
@ -809,7 +809,7 @@ func generatePorts(n int) []discovery.EndpointPort {
ports := []discovery.EndpointPort{} ports := []discovery.EndpointPort{}
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
ports = append(ports, discovery.EndpointPort{ ports = append(ports, discovery.EndpointPort{
Name: utilpointer.StringPtr(fmt.Sprintf("http-%d", i)), Name: utilpointer.String(fmt.Sprintf("http-%d", i)),
Protocol: protocolPtr(api.ProtocolTCP), Protocol: protocolPtr(api.ProtocolTCP),
}) })
} }

2
pkg/apis/networking/fuzzer/fuzzer.go
View File

@ -70,7 +70,7 @@ var Funcs = func(codecs runtimeserializer.CodecFactory) []interface{} {
// default Parameters to Cluster // default Parameters to Cluster
if p.Spec.Parameters == nil || p.Spec.Parameters.Scope == nil { if p.Spec.Parameters == nil || p.Spec.Parameters.Scope == nil {
p.Spec.Parameters = &networking.IngressClassParametersReference{ p.Spec.Parameters = &networking.IngressClassParametersReference{
Scope: utilpointer.StringPtr(networking.IngressClassParametersReferenceScopeCluster), Scope: utilpointer.String(networking.IngressClassParametersReferenceScopeCluster),
} }
} }
}, },

4
pkg/apis/networking/v1/defaults.go
View File

@ -17,7 +17,7 @@ limitations under the License.
package v1 package v1
import ( import (
"k8s.io/api/core/v1" v1 "k8s.io/api/core/v1"
networkingv1 "k8s.io/api/networking/v1" networkingv1 "k8s.io/api/networking/v1"
"k8s.io/apimachinery/pkg/runtime" "k8s.io/apimachinery/pkg/runtime"
utilpointer "k8s.io/utils/pointer" utilpointer "k8s.io/utils/pointer"
@ -47,6 +47,6 @@ func SetDefaults_NetworkPolicy(obj *networkingv1.NetworkPolicy) {
func SetDefaults_IngressClass(obj *networkingv1.IngressClass) { func SetDefaults_IngressClass(obj *networkingv1.IngressClass) {
if obj.Spec.Parameters != nil && obj.Spec.Parameters.Scope == nil { if obj.Spec.Parameters != nil && obj.Spec.Parameters.Scope == nil {
obj.Spec.Parameters.Scope = utilpointer.StringPtr(networkingv1.IngressClassParametersReferenceScopeCluster) obj.Spec.Parameters.Scope = utilpointer.String(networkingv1.IngressClassParametersReferenceScopeCluster)
} }
} }

10
pkg/apis/networking/v1/defaults_test.go
View File

@ -258,7 +258,7 @@ func TestSetDefaultsForIngressClassParametersReference(t *testing.T) {
Parameters: &networkingv1.IngressClassParametersReference{ Parameters: &networkingv1.IngressClassParametersReference{
Kind: "k", Kind: "k",
Name: "n", Name: "n",
Scope: utilpointer.StringPtr(networkingv1.IngressClassParametersReferenceScopeCluster), Scope: utilpointer.String(networkingv1.IngressClassParametersReferenceScopeCluster),
}, },
}, },
}, },
@ -271,8 +271,8 @@ func TestSetDefaultsForIngressClassParametersReference(t *testing.T) {
Parameters: &networkingv1.IngressClassParametersReference{ Parameters: &networkingv1.IngressClassParametersReference{
Kind: "k", Kind: "k",
Name: "n", Name: "n",
Scope: utilpointer.StringPtr(networkingv1.IngressClassParametersReferenceScopeNamespace), Scope: utilpointer.String(networkingv1.IngressClassParametersReferenceScopeNamespace),
Namespace: utilpointer.StringPtr("foo-ns"), Namespace: utilpointer.String("foo-ns"),
}, },
}, },
}, },
@ -282,8 +282,8 @@ func TestSetDefaultsForIngressClassParametersReference(t *testing.T) {
Parameters: &networkingv1.IngressClassParametersReference{ Parameters: &networkingv1.IngressClassParametersReference{
Kind: "k", Kind: "k",
Name: "n", Name: "n",
Scope: utilpointer.StringPtr(networkingv1.IngressClassParametersReferenceScopeNamespace), Scope: utilpointer.String(networkingv1.IngressClassParametersReferenceScopeNamespace),
Namespace: utilpointer.StringPtr("foo-ns"), Namespace: utilpointer.String("foo-ns"),
}, },
}, },
}, },

2
pkg/apis/networking/validation/validation.go
View File

@ -599,7 +599,7 @@ func validateIngressClassParametersReference(params *networking.IngressClassPara
} }
if params.Scope != nil || params.Namespace != nil { if params.Scope != nil || params.Namespace != nil {
scope := utilpointer.StringPtrDerefOr(params.Scope, "") scope := utilpointer.StringDeref(params.Scope, "")
if !supportedIngressClassParametersReferenceScopes.Has(scope) { if !supportedIngressClassParametersReferenceScopes.Has(scope) {
allErrs = append(allErrs, field.NotSupported(fldPath.Child("scope"), scope, allErrs = append(allErrs, field.NotSupported(fldPath.Child("scope"), scope,

46
pkg/apis/networking/validation/validation_test.go
View File

@ -61,7 +61,7 @@ func makePort(proto *api.Protocol, port intstr.IntOrString, endPort int32) netwo
r.Port = &port r.Port = &port
} }
if endPort != 0 { if endPort != 0 {
r.EndPort = utilpointer.Int32Ptr(endPort) r.EndPort = utilpointer.Int32(endPort)
} }
return r return r
} }
@ -735,7 +735,7 @@ func TestValidateIngress(t *testing.T) {
Backend: networking.IngressBackend{ Backend: networking.IngressBackend{
Service: serviceBackend, Service: serviceBackend,
Resource: &api.TypedLocalObjectReference{ Resource: &api.TypedLocalObjectReference{
APIGroup: utilpointer.StringPtr("example.com"), APIGroup: utilpointer.String("example.com"),
Kind: "foo", Kind: "foo",
Name: "bar", Name: "bar",
}, },
@ -760,7 +760,7 @@ func TestValidateIngress(t *testing.T) {
Backend: networking.IngressBackend{ Backend: networking.IngressBackend{
Service: serviceBackend, Service: serviceBackend,
Resource: &api.TypedLocalObjectReference{ Resource: &api.TypedLocalObjectReference{
APIGroup: utilpointer.StringPtr("example.com"), APIGroup: utilpointer.String("example.com"),
Kind: "foo", Kind: "foo",
Name: "bar", Name: "bar",
}, },
@ -779,7 +779,7 @@ func TestValidateIngress(t *testing.T) {
ing.Spec.DefaultBackend = &networking.IngressBackend{ ing.Spec.DefaultBackend = &networking.IngressBackend{
Service: serviceBackend, Service: serviceBackend,
Resource: &api.TypedLocalObjectReference{ Resource: &api.TypedLocalObjectReference{
APIGroup: utilpointer.StringPtr("example.com"), APIGroup: utilpointer.String("example.com"),
Kind: "foo", Kind: "foo",
Name: "bar", Name: "bar",
}, },
@ -794,7 +794,7 @@ func TestValidateIngress(t *testing.T) {
ing.Spec.DefaultBackend = &networking.IngressBackend{ ing.Spec.DefaultBackend = &networking.IngressBackend{
Service: serviceBackend, Service: serviceBackend,
Resource: &api.TypedLocalObjectReference{ Resource: &api.TypedLocalObjectReference{
APIGroup: utilpointer.StringPtr("example.com"), APIGroup: utilpointer.String("example.com"),
Kind: "foo", Kind: "foo",
Name: "bar", Name: "bar",
}, },
@ -961,7 +961,7 @@ func TestValidateIngressCreate(t *testing.T) {
Service: serviceBackend, Service: serviceBackend,
} }
resourceBackend := &api.TypedLocalObjectReference{ resourceBackend := &api.TypedLocalObjectReference{
APIGroup: utilpointer.StringPtr("example.com"), APIGroup: utilpointer.String("example.com"),
Kind: "foo", Kind: "foo",
Name: "bar", Name: "bar",
} }
@ -983,7 +983,7 @@ func TestValidateIngressCreate(t *testing.T) {
}{ }{
"class field set": { "class field set": {
tweakIngress: func(ingress *networking.Ingress) { tweakIngress: func(ingress *networking.Ingress) {
ingress.Spec.IngressClassName = utilpointer.StringPtr("bar") ingress.Spec.IngressClassName = utilpointer.String("bar")
}, },
expectedErrs: field.ErrorList{}, expectedErrs: field.ErrorList{},
}, },
@ -995,7 +995,7 @@ func TestValidateIngressCreate(t *testing.T) {
}, },
"class field and annotation set": { "class field and annotation set": {
tweakIngress: func(ingress *networking.Ingress) { tweakIngress: func(ingress *networking.Ingress) {
ingress.Spec.IngressClassName = utilpointer.StringPtr("bar") ingress.Spec.IngressClassName = utilpointer.String("bar")
ingress.Annotations = map[string]string{annotationIngressClass: "foo"} ingress.Annotations = map[string]string{annotationIngressClass: "foo"}
}, },
expectedErrs: field.ErrorList{field.Invalid(field.NewPath("annotations").Child(annotationIngressClass), "foo", "can not be set when the class field is also set")}, expectedErrs: field.ErrorList{field.Invalid(field.NewPath("annotations").Child(annotationIngressClass), "foo", "can not be set when the class field is also set")},
@ -1138,7 +1138,7 @@ func TestValidateIngressUpdate(t *testing.T) {
Service: serviceBackend, Service: serviceBackend,
} }
resourceBackend := &api.TypedLocalObjectReference{ resourceBackend := &api.TypedLocalObjectReference{
APIGroup: utilpointer.StringPtr("example.com"), APIGroup: utilpointer.String("example.com"),
Kind: "foo", Kind: "foo",
Name: "bar", Name: "bar",
} }
@ -1159,7 +1159,7 @@ func TestValidateIngressUpdate(t *testing.T) {
}{ }{
"class field set": { "class field set": {
tweakIngresses: func(newIngress, oldIngress *networking.Ingress) { tweakIngresses: func(newIngress, oldIngress *networking.Ingress) {
newIngress.Spec.IngressClassName = utilpointer.StringPtr("bar") newIngress.Spec.IngressClassName = utilpointer.String("bar")
}, },
expectedErrs: field.ErrorList{}, expectedErrs: field.ErrorList{},
}, },
@ -1171,7 +1171,7 @@ func TestValidateIngressUpdate(t *testing.T) {
}, },
"class field and annotation set": { "class field and annotation set": {
tweakIngresses: func(newIngress, oldIngress *networking.Ingress) { tweakIngresses: func(newIngress, oldIngress *networking.Ingress) {
newIngress.Spec.IngressClassName = utilpointer.StringPtr("bar") newIngress.Spec.IngressClassName = utilpointer.String("bar")
newIngress.Annotations = map[string]string{annotationIngressClass: "foo"} newIngress.Annotations = map[string]string{annotationIngressClass: "foo"}
}, },
expectedErrs: field.ErrorList{}, expectedErrs: field.ErrorList{},
@ -1595,44 +1595,44 @@ func TestValidateIngressClass(t *testing.T) {
}, },
"valid name, valid controller, valid params": { "valid name, valid controller, valid params": {
ingressClass: makeValidIngressClass("test123", "foo.co/bar", ingressClass: makeValidIngressClass("test123", "foo.co/bar",
setParams(makeIngressClassParams(utilpointer.StringPtr("example.com"), "foo", "bar", utilpointer.StringPtr("Cluster"), nil)), setParams(makeIngressClassParams(utilpointer.String("example.com"), "foo", "bar", utilpointer.String("Cluster"), nil)),
), ),
expectedErrs: field.ErrorList{}, expectedErrs: field.ErrorList{},
}, },
"valid name, valid controller, invalid params (no kind)": { "valid name, valid controller, invalid params (no kind)": {
ingressClass: makeValidIngressClass("test123", "foo.co/bar", ingressClass: makeValidIngressClass("test123", "foo.co/bar",
setParams(makeIngressClassParams(utilpointer.StringPtr("example.com"), "", "bar", utilpointer.StringPtr("Cluster"), nil)), setParams(makeIngressClassParams(utilpointer.String("example.com"), "", "bar", utilpointer.String("Cluster"), nil)),
), ),
expectedErrs: field.ErrorList{field.Required(field.NewPath("spec.parameters.kind"), "kind is required")}, expectedErrs: field.ErrorList{field.Required(field.NewPath("spec.parameters.kind"), "kind is required")},
}, },
"valid name, valid controller, invalid params (no name)": { "valid name, valid controller, invalid params (no name)": {
ingressClass: makeValidIngressClass("test123", "foo.co/bar", ingressClass: makeValidIngressClass("test123", "foo.co/bar",
setParams(makeIngressClassParams(utilpointer.StringPtr("example.com"), "foo", "", utilpointer.StringPtr("Cluster"), nil)), setParams(makeIngressClassParams(utilpointer.String("example.com"), "foo", "", utilpointer.String("Cluster"), nil)),
), ),
expectedErrs: field.ErrorList{field.Required(field.NewPath("spec.parameters.name"), "name is required")}, expectedErrs: field.ErrorList{field.Required(field.NewPath("spec.parameters.name"), "name is required")},
}, },
"valid name, valid controller, invalid params (bad kind)": { "valid name, valid controller, invalid params (bad kind)": {
ingressClass: makeValidIngressClass("test123", "foo.co/bar", ingressClass: makeValidIngressClass("test123", "foo.co/bar",
setParams(makeIngressClassParams(nil, "foo/", "bar", utilpointer.StringPtr("Cluster"), nil)), setParams(makeIngressClassParams(nil, "foo/", "bar", utilpointer.String("Cluster"), nil)),
), ),
expectedErrs: field.ErrorList{field.Invalid(field.NewPath("spec.parameters.kind"), "foo/", "may not contain '/'")}, expectedErrs: field.ErrorList{field.Invalid(field.NewPath("spec.parameters.kind"), "foo/", "may not contain '/'")},
}, },
"valid name, valid controller, invalid params (bad scope)": { "valid name, valid controller, invalid params (bad scope)": {
ingressClass: makeValidIngressClass("test123", "foo.co/bar", ingressClass: makeValidIngressClass("test123", "foo.co/bar",
setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.StringPtr("bad-scope"), nil)), setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.String("bad-scope"), nil)),
), ),
expectedErrs: field.ErrorList{field.NotSupported(field.NewPath("spec.parameters.scope"), expectedErrs: field.ErrorList{field.NotSupported(field.NewPath("spec.parameters.scope"),
"bad-scope", []string{"Cluster", "Namespace"})}, "bad-scope", []string{"Cluster", "Namespace"})},
}, },
"valid name, valid controller, valid Namespace scope": { "valid name, valid controller, valid Namespace scope": {
ingressClass: makeValidIngressClass("test123", "foo.co/bar", ingressClass: makeValidIngressClass("test123", "foo.co/bar",
setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.StringPtr("Namespace"), utilpointer.StringPtr("foo-ns"))), setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.String("Namespace"), utilpointer.String("foo-ns"))),
), ),
expectedErrs: field.ErrorList{}, expectedErrs: field.ErrorList{},
}, },
"valid name, valid controller, valid scope, invalid namespace": { "valid name, valid controller, valid scope, invalid namespace": {
ingressClass: makeValidIngressClass("test123", "foo.co/bar", ingressClass: makeValidIngressClass("test123", "foo.co/bar",
setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.StringPtr("Namespace"), utilpointer.StringPtr("foo_ns"))), setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.String("Namespace"), utilpointer.String("foo_ns"))),
), ),
expectedErrs: field.ErrorList{field.Invalid(field.NewPath("spec.parameters.namespace"), "foo_ns", expectedErrs: field.ErrorList{field.Invalid(field.NewPath("spec.parameters.namespace"), "foo_ns",
"a lowercase RFC 1123 label must consist of lower case alphanumeric characters or '-',"+ "a lowercase RFC 1123 label must consist of lower case alphanumeric characters or '-',"+
@ -1641,27 +1641,27 @@ func TestValidateIngressClass(t *testing.T) {
}, },
"valid name, valid controller, valid Cluster scope": { "valid name, valid controller, valid Cluster scope": {
ingressClass: makeValidIngressClass("test123", "foo.co/bar", ingressClass: makeValidIngressClass("test123", "foo.co/bar",
setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.StringPtr("Cluster"), nil)), setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.String("Cluster"), nil)),
), ),
expectedErrs: field.ErrorList{}, expectedErrs: field.ErrorList{},
}, },
"namespace not set when scope is Namespace": { "namespace not set when scope is Namespace": {
ingressClass: makeValidIngressClass("test123", "foo.co/bar", ingressClass: makeValidIngressClass("test123", "foo.co/bar",
setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.StringPtr("Namespace"), nil)), setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.String("Namespace"), nil)),
), ),
expectedErrs: field.ErrorList{field.Required(field.NewPath("spec.parameters.namespace"), expectedErrs: field.ErrorList{field.Required(field.NewPath("spec.parameters.namespace"),
"`parameters.scope` is set to 'Namespace'")}, "`parameters.scope` is set to 'Namespace'")},
}, },
"namespace is forbidden when scope is Cluster": { "namespace is forbidden when scope is Cluster": {
ingressClass: makeValidIngressClass("test123", "foo.co/bar", ingressClass: makeValidIngressClass("test123", "foo.co/bar",
setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.StringPtr("Cluster"), utilpointer.StringPtr("foo-ns"))), setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.String("Cluster"), utilpointer.String("foo-ns"))),
), ),
expectedErrs: field.ErrorList{field.Forbidden(field.NewPath("spec.parameters.namespace"), expectedErrs: field.ErrorList{field.Forbidden(field.NewPath("spec.parameters.namespace"),
"`parameters.scope` is set to 'Cluster'")}, "`parameters.scope` is set to 'Cluster'")},
}, },
"empty namespace is forbidden when scope is Cluster": { "empty namespace is forbidden when scope is Cluster": {
ingressClass: makeValidIngressClass("test123", "foo.co/bar", ingressClass: makeValidIngressClass("test123", "foo.co/bar",
setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.StringPtr("Cluster"), utilpointer.StringPtr(""))), setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.String("Cluster"), utilpointer.String(""))),
), ),
expectedErrs: field.ErrorList{field.Forbidden(field.NewPath("spec.parameters.namespace"), expectedErrs: field.ErrorList{field.Forbidden(field.NewPath("spec.parameters.namespace"),
"`parameters.scope` is set to 'Cluster'")}, "`parameters.scope` is set to 'Cluster'")},
@ -1712,7 +1712,7 @@ func TestValidateIngressClassUpdate(t *testing.T) {
newIngressClass: makeValidIngressClass("test123", "foo.co/bar", newIngressClass: makeValidIngressClass("test123", "foo.co/bar",
setResourceVersion("2"), setResourceVersion("2"),
setParams( setParams(
makeIngressClassParams(utilpointer.StringPtr("v1"), "ConfigMap", "foo", utilpointer.StringPtr("Namespace"), utilpointer.StringPtr("bar")), makeIngressClassParams(utilpointer.String("v1"), "ConfigMap", "foo", utilpointer.String("Namespace"), utilpointer.String("bar")),
), ),
), ),
oldIngressClass: makeValidIngressClass("test123", "foo.co/bar"), oldIngressClass: makeValidIngressClass("test123", "foo.co/bar"),

10
pkg/apis/policy/validation/validation_test.go
View File

@ -1064,13 +1064,13 @@ func TestValidateRuntimeClassStrategy(t *testing.T) {
}, { }, {
name: "valid defaulting & allow all", name: "valid defaulting & allow all",
strategy: &policy.RuntimeClassStrategyOptions{ strategy: &policy.RuntimeClassStrategyOptions{
DefaultRuntimeClassName: pointer.StringPtr("native"), DefaultRuntimeClassName: pointer.String("native"),
AllowedRuntimeClassNames: []string{"*"}, AllowedRuntimeClassNames: []string{"*"},
}, },
}, { }, {
name: "valid defaulting & allow explicit", name: "valid defaulting & allow explicit",
strategy: &policy.RuntimeClassStrategyOptions{ strategy: &policy.RuntimeClassStrategyOptions{
DefaultRuntimeClassName: pointer.StringPtr("native"), DefaultRuntimeClassName: pointer.String("native"),
AllowedRuntimeClassNames: []string{"foo", "native", "sandboxed"}, AllowedRuntimeClassNames: []string{"foo", "native", "sandboxed"},
}, },
}, { }, {
@ -1081,20 +1081,20 @@ func TestValidateRuntimeClassStrategy(t *testing.T) {
}, { }, {
name: "invalid default name", name: "invalid default name",
strategy: &policy.RuntimeClassStrategyOptions{ strategy: &policy.RuntimeClassStrategyOptions{
DefaultRuntimeClassName: pointer.StringPtr("foo bar"), DefaultRuntimeClassName: pointer.String("foo bar"),
}, },
expectErrors: true, expectErrors: true,
}, { }, {
name: "disallowed default", name: "disallowed default",
strategy: &policy.RuntimeClassStrategyOptions{ strategy: &policy.RuntimeClassStrategyOptions{
DefaultRuntimeClassName: pointer.StringPtr("foo"), DefaultRuntimeClassName: pointer.String("foo"),
AllowedRuntimeClassNames: []string{"native", "sandboxed"}, AllowedRuntimeClassNames: []string{"native", "sandboxed"},
}, },
expectErrors: true, expectErrors: true,
}, { }, {
name: "nothing allowed default", name: "nothing allowed default",
strategy: &policy.RuntimeClassStrategyOptions{ strategy: &policy.RuntimeClassStrategyOptions{
DefaultRuntimeClassName: pointer.StringPtr("foo"), DefaultRuntimeClassName: pointer.String("foo"),
}, },
expectErrors: true, expectErrors: true,
}, { }, {